-- /dev/null

++ icedtea-web/netx/sun/applet/AppletImageRef.java

-- icedtea-web.orig/configure.ac

/*

 * Copyright (c) 1995, 2014, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.awt.Toolkit;

import java.awt.Image;

import java.lang.ref.SoftReference;

import sun.awt.image.URLImageSource;

import java.net.URL;

@Deprecated(since = "9")

class AppletImageRef {

    private SoftReference<Image> soft = null;

    URL url;

    /**

     * Returns a pointer to the object referenced by this Ref.  If the object

     * has been thrown away by the garbage collector, it will be

     * reconstituted. This method does everything necessary to ensure that the garbage

     * collector throws things away in Least Recently Used(LRU) order.  Applications should

     * never override this method. The get() method effectively caches calls to

     * reconstitute().

     */

    public synchronized Image get() {

        Image t = check();

        if (t == null) {

            t = reconstitute();

            setThing(t);

        }

        return t;

    }

    /**

     * Create the Ref

     */

    AppletImageRef(URL url) {

        this.url = url;

    }

    /**

     * Flushes the cached object.  Forces the next invocation of get() to

     * invoke reconstitute().

     */

    public synchronized void flush() {

        SoftReference<Image> s = soft;

        if (s != null) s.clear();

        soft = null;

    }

    /**

     * Sets the thing to the specified object.

     * @param thing the specified object

     */

    public synchronized void setThing(Image thing) {

        flush();

        soft = new SoftReference<>(thing);

    }

    /**

     * Checks to see what object is being pointed at by this Ref and returns it.

     */

    public synchronized Image check() {

        SoftReference<Image> s = soft;

        if (s == null) return null;

        return s.get();

    }

    /**

     * Reconsitute the image.  Only called when the ref has been flushed.

     */

    public Image reconstitute() {

        Image img = Toolkit.getDefaultToolkit().createImage(new URLImageSource(url));

        return img;

    }

}

IT_CHECK_FOR_CLASS(SUN_APPLET_APPLETIMAGEREF, [sun.applet.AppletImageRef], [sun.applet], [$JAVA_DESKTOP])

dnl IT_CHECK_FOR_CLASS(SUN_APPLET_APPLETIMAGEREF, [sun.applet.AppletImageRef], [sun.applet], [$JAVA_DESKTOP])

IT_CHECK_FOR_SUN_APPLET_ACCESSIBILITY

dnl IT_CHECK_FOR_SUN_APPLET_ACCESSIBILITY

-- /dev/null

++ icedtea-web/netx/sun/applet/AppletViewerPanel.java

-- /dev/null

/*

 * Copyright (c) 1995, 2005, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.util.*;

import java.io.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.awt.*;

import java.applet.*;

/**

 * Sample applet panel class. The panel manages and manipulates the

 * applet as it is being loaded. It forks a seperate thread in a new

 * thread group to call the applet's init(), start(), stop(), and

 * destroy() methods.

 *

 * @author      Arthur van Hoff

 *

 * @deprecated The Applet API is deprecated. See the

 * <a href="../../java/applet/package-summary.html"> java.applet package

 * documentation</a> for further information.

 */

@Deprecated(since = "9")

class AppletViewerPanel extends AppletPanel {

    /* Are we debugging? */

    static boolean debug = false;

    /**

     * The document url.

     */

    URL documentURL;

    /**

     * The base url.

     */

    URL baseURL;

    /**

     * The attributes of the applet.

     */

    Hashtable<String, String> atts;

    /*

     * JDK 1.1 serialVersionUID

     */

    private static final long serialVersionUID = 8890989370785545619L;

    /**

     * Construct an applet viewer and start the applet.

     */

    AppletViewerPanel(URL documentURL, Hashtable<String, String> atts) {

        this.documentURL = documentURL;

        this.atts = atts;

        String att = getParameter("codebase");

        if (att != null) {

            if (!att.endsWith("/")) {

                att += "/";

            }

            try {

                baseURL = new URL(documentURL, att);

            } catch (MalformedURLException e) {

            }

        }

        if (baseURL == null) {

            String file = documentURL.getFile();

            int i = file.lastIndexOf('/');

            if (i >= 0 && i < file.length() - 1) {

                try {

                    baseURL = new URL(documentURL, file.substring(0, i + 1));

                } catch (MalformedURLException e) {

                }

            }

        }

        // when all is said & done, baseURL shouldn't be null

        if (baseURL == null)

                baseURL = documentURL;

    }

    /**

     * Get an applet parameter.

     */

    public String getParameter(String name) {

        return atts.get(name.toLowerCase());

    }

    /**

     * Get the document url.

     */

    public URL getDocumentBase() {

        return documentURL;

    }

    /**

     * Get the base url.

     */

    public URL getCodeBase() {

        return baseURL;

    }

    /**

     * Get the width.

     */

    public int getWidth() {

        String w = getParameter("width");

        if (w != null) {

            return Integer.valueOf(w).intValue();

        }

        return 0;

    }

    /**

     * Get the height.

     */

    public int getHeight() {

        String h = getParameter("height");

        if (h != null) {

            return Integer.valueOf(h).intValue();

        }

        return 0;

    }

    /**

     * Get initial_focus

     */

    public boolean hasInitialFocus()

    {

        // 6234219: Do not set initial focus on an applet

        // during startup if applet is targeted for

        // JDK 1.1/1.2. [stanley.ho]

        if (isJDK11Applet() || isJDK12Applet())

            return false;

        String initialFocus = getParameter("initial_focus");

        if (initialFocus != null)

        {

            if (initialFocus.toLowerCase().equals("false"))

                return false;

        }

        return true;

    }

    /**

     * Get the code parameter

     */

    public String getCode() {

        return getParameter("code");

    }

    /**

     * Return the list of jar files if specified.

     * Otherwise return null.

     */

    public String getJarFiles() {

        return getParameter("archive");

    }

    /**

     * Return the value of the object param

     */

    public String getSerializedObject() {

        return getParameter("object");// another name?

    }

    /**

     * Get the applet context. For now this is

     * also implemented by the AppletPanel class.

     */

    @SuppressWarnings("deprecation")

    public AppletContext getAppletContext() {

        return (AppletContext)getParent();

    }

    static void debug(String s) {

        if(debug)

            System.err.println("AppletViewerPanel:::" + s);

    }

    static void debug(String s, Throwable t) {

        if(debug) {

            t.printStackTrace();

            debug(s);

        }

    }

}

-- /dev/null

/*

 * Copyright (c) 1995, 2015, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

import java.io.*;

import java.lang.ref.WeakReference;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.JarURLConnection;

import java.net.SocketPermission;

import java.net.URL;

import java.security.*;

import java.util.*;

import java.util.Locale;

import java.util.concurrent.LinkedBlockingQueue;

import sun.awt.AWTAccessor;

import sun.awt.AppContext;

import sun.awt.EmbeddedFrame;

import sun.awt.SunToolkit;

import sun.security.util.SecurityConstants;

/**

 * Applet panel class. The panel manages and manipulates the

 * applet as it is being loaded. It forks a separate thread in a new

 * thread group to call the applet's init(), start(), stop(), and

 * destroy() methods.

 *

 * @deprecated The Applet API is deprecated. See the

 * <a href="../../java/applet/package-summary.html"> java.applet package

 * documentation</a> for further information.

 *

 * @author      Arthur van Hoff

 */

@SuppressWarnings({"serial"}) // JDK implementation class

@Deprecated(since = "9")

public

abstract class AppletPanel extends Panel implements AppletStub, Runnable {

    /**

     * The applet (if loaded).

     */

    Applet applet;

    /**

     * The classloader for the applet.

     */

    protected AppletClassLoader loader;

    /* applet event ids */

    public static final int APPLET_DISPOSE = 0;

    public static final int APPLET_LOAD = 1;

    public static final int APPLET_INIT = 2;

    public static final int APPLET_START = 3;

    public static final int APPLET_STOP = 4;

    public static final int APPLET_DESTROY = 5;

    public static final int APPLET_QUIT = 6;

    public static final int APPLET_ERROR = 7;

    /* send to the parent to force relayout */

    public static final int APPLET_RESIZE = 51234;

    /* sent to a (distant) parent to indicate that the applet is being

     * loaded or as completed loading

     */

    public static final int APPLET_LOADING = 51235;

    public static final int APPLET_LOADING_COMPLETED = 51236;

    /**

     * The current status. One of:

     *    APPLET_DISPOSE,

     *    APPLET_LOAD,

     *    APPLET_INIT,

     *    APPLET_START,

     *    APPLET_STOP,

     *    APPLET_DESTROY,

     *    APPLET_ERROR.

     */

    protected int status;

    /**

     * The thread for the applet.

     */

    protected Thread handler;

    /**

     * The initial applet size.

     */

    Dimension defaultAppletSize = new Dimension(10, 10);

    /**

     * The current applet size.

     */

    Dimension currentAppletSize = new Dimension(10, 10);

    /**

     * The thread to use during applet loading

     */

    Thread loaderThread = null;

    /**

     * Flag to indicate that a loading has been cancelled

     */

    boolean loadAbortRequest = false;

    /* abstract classes */

    protected abstract String getCode();

    protected abstract String getJarFiles();

    @Override

    public abstract int    getWidth();

    @Override

    public abstract int    getHeight();

    public abstract boolean hasInitialFocus();

    private static int threadGroupNumber = 0;

    protected void setupAppletAppContext() {

        // do nothing

    }

    /*

     * Creates a thread to run the applet. This method is called

     * each time an applet is loaded and reloaded.

     */

    synchronized void createAppletThread() {

        // Create a thread group for the applet, and start a new

        // thread to load the applet.

        String nm = "applet-" + getCode();

        loader = getClassLoader(getCodeBase(), getClassLoaderCacheKey());

        loader.grab(); // Keep this puppy around!

        // 4668479: Option to turn off codebase lookup in AppletClassLoader

        // during resource requests. [stanley.ho]

        String param = getParameter("codebase_lookup");

        if (param != null && param.equals("false"))

            loader.setCodebaseLookup(false);

        else

            loader.setCodebaseLookup(true);

        ThreadGroup appletGroup = loader.getThreadGroup();

        handler = new Thread(appletGroup, this, "thread " + nm, 0, false);

        // set the context class loader for this thread

        AccessController.doPrivileged(new PrivilegedAction<Object>() {

                @Override

                public Object run() {

                    handler.setContextClassLoader(loader);

                    return null;

                }

            });

        handler.start();

    }

    void joinAppletThread() throws InterruptedException {

        if (handler != null) {

            handler.join();

            handler = null;

        }

    }

    void release() {

        if (loader != null) {

            loader.release();

            loader = null;

        }

    }

    /**

     * Construct an applet viewer and start the applet.

     */

    public void init() {

        try {

            // Get the width (if any)

            defaultAppletSize.width = getWidth();

            currentAppletSize.width = defaultAppletSize.width;

            // Get the height (if any)

            defaultAppletSize.height = getHeight();

            currentAppletSize.height = defaultAppletSize.height;

        } catch (NumberFormatException e) {

            // Turn on the error flag and let TagAppletPanel

            // do the right thing.

            status = APPLET_ERROR;

            showAppletStatus("badattribute.exception");

            showAppletLog("badattribute.exception");

            showAppletException(e);

        }

        setLayout(new BorderLayout());

        createAppletThread();

    }

    /**

     * Minimum size

     */

    @Override

    @SuppressWarnings("deprecation")

    public Dimension minimumSize() {

        return new Dimension(defaultAppletSize.width,

                             defaultAppletSize.height);

    }

    /**

     * Preferred size

     */

    @Override

    @SuppressWarnings("deprecation")

    public Dimension preferredSize() {

        return new Dimension(currentAppletSize.width,

                             currentAppletSize.height);

    }

    private AppletListener listeners;

    /**

     * AppletEvent Queue

     */

    private LinkedBlockingQueue<Integer> queue = null;

    public synchronized void addAppletListener(AppletListener l) {

        listeners = AppletEventMulticaster.add(listeners, l);

    }

    public synchronized void removeAppletListener(AppletListener l) {

        listeners = AppletEventMulticaster.remove(listeners, l);

    }

    /**

     * Dispatch event to the listeners..

     */

    public void dispatchAppletEvent(int id, Object argument) {

        //System.out.println("SEND= " + id);

        if (listeners != null) {

            AppletEvent evt = new AppletEvent(this, id, argument);

            listeners.appletStateChanged(evt);

        }

    }

    /**

     * Send an event. Queue it for execution by the handler thread.

     */

    public void sendEvent(int id) {

        synchronized(this) {

            if (queue == null) {

                //System.out.println("SEND0= " + id);

                queue = new LinkedBlockingQueue<>();

            }

            boolean inserted = queue.add(id);

            notifyAll();

        }

        if (id == APPLET_QUIT) {

            try {

                joinAppletThread(); // Let the applet event handler exit

            } catch (InterruptedException e) {

            }

            // AppletClassLoader.release() must be called by a Thread

            // not within the applet's ThreadGroup

            if (loader == null)

                loader = getClassLoader(getCodeBase(), getClassLoaderCacheKey());

            release();

        }

    }

    /**

     * Get an event from the queue.

     */

    synchronized AppletEvent getNextEvent() throws InterruptedException {

        while (queue == null || queue.isEmpty()) {

            wait();

        }

        int eventId = queue.take();

        return new AppletEvent(this, eventId, null);

    }

    boolean emptyEventQueue() {

        if ((queue == null) || (queue.isEmpty()))

            return true;

        else

            return false;

    }

    /**

     * This kludge is specific to get over AccessControlException thrown during

     * Applet.stop() or destroy() when static thread is suspended.  Set a flag

     * in AppletClassLoader to indicate that an

     * AccessControlException for RuntimePermission "modifyThread" or

     * "modifyThreadGroup" had occurred.

     */

     private void setExceptionStatus(AccessControlException e) {

     Permission p = e.getPermission();

     if (p instanceof RuntimePermission) {

         if (p.getName().startsWith("modifyThread")) {

             if (loader == null)

                 loader = getClassLoader(getCodeBase(), getClassLoaderCacheKey());

             loader.setExceptionStatus();

         }

     }

     }

    /**

     * Execute applet events.

     * Here is the state transition diagram

     *

     * <pre>{@literal

     *   Note: (XXX) is the action

     *         APPLET_XXX is the state

     *  (applet code loaded) --> APPLET_LOAD -- (applet init called)--> APPLET_INIT --

     *  (applet start called) --> APPLET_START -- (applet stop called) --> APPLET_STOP --

     *  (applet destroyed called) --> APPLET_DESTROY --> (applet gets disposed) -->

     *   APPLET_DISPOSE --> ...

     * }</pre>

     *

     * In the legacy lifecycle model. The applet gets loaded, inited and started. So it stays

     * in the APPLET_START state unless the applet goes away(refresh page or leave the page).

     * So the applet stop method called and the applet enters APPLET_STOP state. Then if the applet

     * is revisited, it will call applet start method and enter the APPLET_START state and stay there.

     *

     * In the modern lifecycle model. When the applet first time visited, it is same as legacy lifecycle

     * model. However, when the applet page goes away. It calls applet stop method and enters APPLET_STOP

     * state and then applet destroyed method gets called and enters APPLET_DESTROY state.

     *

     * This code is also called by AppletViewer. In AppletViewer "Restart" menu, the applet is jump from

     * APPLET_STOP to APPLET_DESTROY and to APPLET_INIT .

     *

     * Also, the applet can jump from APPLET_INIT state to APPLET_DESTROY (in Netscape/Mozilla case).

     * Same as APPLET_LOAD to

     * APPLET_DISPOSE since all of this are triggered by browser.

     *

     */

    @Override

    public void run() {

        Thread curThread = Thread.currentThread();

        if (curThread == loaderThread) {

            // if we are in the loader thread, cause

            // loading to occur.  We may exit this with

            // status being APPLET_DISPOSE, APPLET_ERROR,

            // or APPLET_LOAD

            runLoader();

            return;

        }

        boolean disposed = false;

        while (!disposed && !curThread.isInterrupted()) {

            AppletEvent evt;

            try {

                evt = getNextEvent();

            } catch (InterruptedException e) {

                showAppletStatus("bail");

                return;

            }

            //showAppletStatus("EVENT = " + evt.getID());

            try {

                switch (evt.getID()) {

                  case APPLET_LOAD:

                      if (!okToLoad()) {

                          break;

                      }

                      // This complexity allows loading of applets to be

                      // interruptable.  The actual thread loading runs

                      // in a separate thread, so it can be interrupted

                      // without harming the applet thread.

                      // So that we don't have to worry about

                      // concurrency issues, the main applet thread waits

                      // until the loader thread terminates.

                      // (one way or another).

                      if (loaderThread == null) {

                          setLoaderThread(new Thread(null, this,

                                          "AppletLoader", 0, false));

                          loaderThread.start();

                          // we get to go to sleep while this runs

                          loaderThread.join();

                          setLoaderThread(null);

                      } else {

                          // REMIND: issue an error -- this case should never

                          // occur.

                      }

                      break;

                  case APPLET_INIT:

                    // AppletViewer "Restart" will jump from destroy method to

                    // init, that is why we need to check status w/ APPLET_DESTROY

                      if (status != APPLET_LOAD && status != APPLET_DESTROY) {

                          showAppletStatus("notloaded");

                          break;

                      }

                      applet.resize(defaultAppletSize);

                      applet.init();

                      //Need the default(fallback) font to be created in this AppContext

                      Font f = getFont();

                      if (f == null ||

                          "dialog".equals(f.getFamily().toLowerCase(Locale.ENGLISH)) &&

                          f.getSize() == 12 && f.getStyle() == Font.PLAIN) {

                          setFont(new Font(Font.DIALOG, Font.PLAIN, 12));

                      }

                      // Validate the applet in event dispatch thread

                      // to avoid deadlock.

                      try {

                          final AppletPanel p = this;

                          Runnable r = new Runnable() {

                              @Override

                              public void run() {

                                  p.validate();

                              }

                          };

                          AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);

                      }

                      catch(InterruptedException ie) {

                      }

                      catch(InvocationTargetException ite) {

                      }

                      status = APPLET_INIT;

                      showAppletStatus("inited");

                      break;

                  case APPLET_START:

                  {

                      if (status != APPLET_INIT && status != APPLET_STOP) {

                          showAppletStatus("notinited");

                          break;

                      }

                      applet.resize(currentAppletSize);

                      applet.start();

                      // Validate and show the applet in event dispatch thread

                      // to avoid deadlock.

                      try {

                          final AppletPanel p = this;

                          final Applet a = applet;

                          Runnable r = new Runnable() {

                              @Override

                              public void run() {

                                  p.validate();

                                  a.setVisible(true);

                                  // Fix for BugTraq ID 4041703.

                                  // Set the default focus for an applet.

                                  if (hasInitialFocus()) {

                                      setDefaultFocus();

                                  }

                              }

                          };

                          AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);

                      }

                      catch(InterruptedException ie) {

                      }

                      catch(InvocationTargetException ite) {

                      }

                      status = APPLET_START;

                      showAppletStatus("started");

                      break;

                  }

                case APPLET_STOP:

                    if (status != APPLET_START) {

                        showAppletStatus("notstarted");

                        break;

                    }

                    status = APPLET_STOP;

                    // Hide the applet in event dispatch thread

                    // to avoid deadlock.

                    try {

                        final Applet a = applet;

                        Runnable r = new Runnable() {

                            @Override

                            public void run() {

                                a.setVisible(false);

                            }

                        };

                        AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);

                    }

                    catch(InterruptedException ie) {

                    }

                    catch(InvocationTargetException ite) {

                    }

                    // During Applet.stop(), any AccessControlException on an involved Class remains in

                    // the "memory" of the AppletClassLoader.  If the same instance of the ClassLoader is

                    // reused, the same exception will occur during class loading.  Set the AppletClassLoader's

                    // exceptionStatusSet flag to allow recognition of what had happened

                    // when reusing AppletClassLoader object.

                    try {

                        applet.stop();

                    } catch (java.security.AccessControlException e) {

                        setExceptionStatus(e);

                        // rethrow exception to be handled as it normally would be.

                        throw e;

                    }

                    showAppletStatus("stopped");

                    break;

                case APPLET_DESTROY:

                    if (status != APPLET_STOP && status != APPLET_INIT) {

                        showAppletStatus("notstopped");

                        break;

                    }

                    status = APPLET_DESTROY;

                    // During Applet.destroy(), any AccessControlException on an involved Class remains in

                    // the "memory" of the AppletClassLoader.  If the same instance of the ClassLoader is

                    // reused, the same exception will occur during class loading.  Set the AppletClassLoader's

                    // exceptionStatusSet flag to allow recognition of what had happened

                    // when reusing AppletClassLoader object.

                    try {

                        applet.destroy();

                    } catch (java.security.AccessControlException e) {

                        setExceptionStatus(e);

                        // rethrow exception to be handled as it normally would be.

                        throw e;

                    }

                    showAppletStatus("destroyed");

                    break;

                case APPLET_DISPOSE:

                    if (status != APPLET_DESTROY && status != APPLET_LOAD) {

                        showAppletStatus("notdestroyed");

                        break;

                    }

                    status = APPLET_DISPOSE;

                    try {

                        final Applet a = applet;

                        Runnable r = new Runnable() {

                            @Override

                            public void run() {

                                remove(a);

                            }

                        };

                        AWTAccessor.getEventQueueAccessor().invokeAndWait(applet, r);

                    }

                    catch(InterruptedException ie)

                    {

                    }

                    catch(InvocationTargetException ite)

                    {

                    }

                    applet = null;

                    showAppletStatus("disposed");

                    disposed = true;

                    break;

                case APPLET_QUIT:

                    return;

                }

            } catch (Exception e) {

                status = APPLET_ERROR;

                if (e.getMessage() != null) {

                    showAppletStatus("exception2", e.getClass().getName(),

                                     e.getMessage());

                } else {

                    showAppletStatus("exception", e.getClass().getName());

                }

                showAppletException(e);

            } catch (ThreadDeath e) {

                showAppletStatus("death");

                return;

            } catch (Error e) {

                status = APPLET_ERROR;

                if (e.getMessage() != null) {

                    showAppletStatus("error2", e.getClass().getName(),

                                     e.getMessage());

                } else {

                    showAppletStatus("error", e.getClass().getName());

                }

                showAppletException(e);

            }

            clearLoadAbortRequest();

        }

    }

    /**

     * Gets most recent focus owner component associated with the given window.

     * It does that without calling Window.getMostRecentFocusOwner since it

     * provides its own logic contradicting with setDefautlFocus. Instead, it

     * calls KeyboardFocusManager directly.

     */

    private Component getMostRecentFocusOwnerForWindow(Window w) {

        return AWTAccessor.getKeyboardFocusManagerAccessor()

                .getMostRecentFocusOwner(w);

    }

    /*

     * Fix for BugTraq ID 4041703.

     * Set the focus to a reasonable default for an Applet.

     */

    private void setDefaultFocus() {

        Component toFocus = null;

        Container parent = getParent();

        if(parent != null) {

            if (parent instanceof Window) {

                toFocus = getMostRecentFocusOwnerForWindow((Window)parent);

                if (toFocus == parent || toFocus == null) {

                    toFocus = parent.getFocusTraversalPolicy().

                        getInitialComponent((Window)parent);

                }

            } else if (parent.isFocusCycleRoot()) {

                toFocus = parent.getFocusTraversalPolicy().

                    getDefaultComponent(parent);

            }

        }

        if (toFocus != null) {

            if (parent instanceof EmbeddedFrame) {

                ((EmbeddedFrame) parent).synthesizeWindowActivation(true);

            }

            // EmbeddedFrame might have focus before the applet was added.

            // Thus after its activation the most recent focus owner will be

            // restored. We need the applet's initial focusabled component to

            // be focused here.

            toFocus.requestFocusInWindow();

        }

    }

    /**

     * Load the applet into memory.

     * Runs in a seperate (and interruptible) thread from the rest of the

     * applet event processing so that it can be gracefully interrupted from

     * things like HotJava.

     */

    @SuppressWarnings("deprecation")

    private void runLoader() {

        if (status != APPLET_DISPOSE) {

            showAppletStatus("notdisposed");

            return;

        }

        dispatchAppletEvent(APPLET_LOADING, null);

        // REMIND -- might be cool to visually indicate loading here --

        // maybe do animation?

        status = APPLET_LOAD;

        // Create a class loader

        loader = getClassLoader(getCodeBase(), getClassLoaderCacheKey());

        // Load the archives if present.

        // REMIND - this probably should be done in a separate thread,

        // or at least the additional archives (epll).

        String code = getCode();

        // setup applet AppContext

        // this must be called before loadJarFiles

        setupAppletAppContext();

        try {

            loadJarFiles(loader);

            applet = createApplet(loader);

        } catch (ClassNotFoundException e) {

            status = APPLET_ERROR;

            showAppletStatus("notfound", code);

            showAppletLog("notfound", code);

            showAppletException(e);

            return;

        } catch (InstantiationException e) {

            status = APPLET_ERROR;

            showAppletStatus("nocreate", code);

            showAppletLog("nocreate", code);

            showAppletException(e);

            return;

        } catch (IllegalAccessException e) {

            status = APPLET_ERROR;

            showAppletStatus("noconstruct", code);

            showAppletLog("noconstruct", code);

            showAppletException(e);

            // sbb -- I added a return here

            return;

        } catch (Exception e) {

            status = APPLET_ERROR;

            showAppletStatus("exception", e.getMessage());

            showAppletException(e);

            return;

        } catch (ThreadDeath e) {

            status = APPLET_ERROR;

            showAppletStatus("death");

            return;

        } catch (Error e) {

            status = APPLET_ERROR;

            showAppletStatus("error", e.getMessage());

            showAppletException(e);

            return;

        } finally {

            // notify that loading is no longer going on

            dispatchAppletEvent(APPLET_LOADING_COMPLETED, null);

        }

        // Fixed #4508194: NullPointerException thrown during

        // quick page switch

        //

        if (applet != null)

        {

            // Stick it in the frame

            applet.setStub(this);

            applet.hide();

            add("Center", applet);

            showAppletStatus("loaded");

            validate();

        }

    }

    protected Applet createApplet(final AppletClassLoader loader) throws ClassNotFoundException,

                                                                         IllegalAccessException, IOException, InstantiationException, InterruptedException {

        String code = getCode();

        if (code != null) {

            applet = (Applet)loader.loadCode(code).newInstance();

        } else {

            String msg = "nocode";

            status = APPLET_ERROR;

            showAppletStatus(msg);

            showAppletLog(msg);

            repaint();

        }

        // Determine the JDK level that the applet targets.

        // This is critical for enabling certain backward

        // compatibility switch if an applet is a JDK 1.1

        // applet. [stanley.ho]

        findAppletJDKLevel(applet);

        if (Thread.interrupted()) {

            try {

                status = APPLET_DISPOSE; // APPLET_ERROR?

                applet = null;

                // REMIND: This may not be exactly the right thing: the

                // status is set by the stop button and not necessarily

                // here.

                showAppletStatus("death");

            } finally {

                Thread.currentThread().interrupt(); // resignal interrupt

            }

            return null;

        }

        return applet;

    }

    protected void loadJarFiles(AppletClassLoader loader) throws IOException,

                                                                 InterruptedException {

        // Load the archives if present.

        // REMIND - this probably should be done in a separate thread,

        // or at least the additional archives (epll).

        String jarFiles = getJarFiles();

        if (jarFiles != null) {

            StringTokenizer st = new StringTokenizer(jarFiles, ",", false);

            while(st.hasMoreTokens()) {

                String tok = st.nextToken().trim();

                try {

                    loader.addJar(tok);

                } catch (IllegalArgumentException e) {

                    // bad archive name

                    continue;

                }

            }

        }

    }

    /**

     * Request that the loading of the applet be stopped.

     */

    protected synchronized void stopLoading() {

        // REMIND: fill in the body

        if (loaderThread != null) {

            //System.out.println("Interrupting applet loader thread: " + loaderThread);

            loaderThread.interrupt();

        } else {

            setLoadAbortRequest();

        }

    }

    protected synchronized boolean okToLoad() {

        return !loadAbortRequest;

    }

    protected synchronized void clearLoadAbortRequest() {

        loadAbortRequest = false;

    }

    protected synchronized void setLoadAbortRequest() {

        loadAbortRequest = true;

    }

    private synchronized void setLoaderThread(Thread loaderThread) {

        this.loaderThread = loaderThread;

    }

    /**

     * Return true when the applet has been started.

     */

    @Override

    public boolean isActive() {

        return status == APPLET_START;

    }

    private EventQueue appEvtQ = null;

    /**

     * Is called when the applet wants to be resized.

     */

    @Override

    public void appletResize(int width, int height) {

        currentAppletSize.width = width;

        currentAppletSize.height = height;

        final Dimension currentSize = new Dimension(currentAppletSize.width,

                                                    currentAppletSize.height);

        if(loader != null) {

            AppContext appCtxt = loader.getAppContext();

            if(appCtxt != null)

                appEvtQ = (java.awt.EventQueue)appCtxt.get(AppContext.EVENT_QUEUE_KEY);

        }

        final AppletPanel ap = this;

        if (appEvtQ != null){

            appEvtQ.postEvent(new InvocationEvent(Toolkit.getDefaultToolkit(),

                                                  new Runnable() {

                                                      @Override

                                                      public void run() {

                                                          if (ap != null) {

                                                              ap.dispatchAppletEvent(

                                                                      APPLET_RESIZE,

                                                                      currentSize);

                                                          }

                                                      }

                                                  }));

        }

    }

    @Override

    public void setBounds(int x, int y, int width, int height) {

        super.setBounds(x, y, width, height);

        currentAppletSize.width = width;

        currentAppletSize.height = height;

    }

    public Applet getApplet() {

        return applet;

    }

    /**

     * Status line. Called by the AppletPanel to provide

     * feedback on the Applet's state.

     */

    protected void showAppletStatus(String status) {

        getAppletContext().showStatus(amh.getMessage(status));

    }

    protected void showAppletStatus(String status, Object arg) {

        getAppletContext().showStatus(amh.getMessage(status, arg));

    }

    protected void showAppletStatus(String status, Object arg1, Object arg2) {

        getAppletContext().showStatus(amh.getMessage(status, arg1, arg2));

    }

    /**

     * Called by the AppletPanel to print to the log.

     */

    protected void showAppletLog(String msg) {

        System.out.println(amh.getMessage(msg));

    }

    protected void showAppletLog(String msg, Object arg) {

        System.out.println(amh.getMessage(msg, arg));

    }

    /**

     * Called by the AppletPanel to provide

     * feedback when an exception has happened.

     */

    protected void showAppletException(Throwable t) {

        t.printStackTrace();

        repaint();

    }

    /**

     * Get caching key for classloader cache

     */

    public String getClassLoaderCacheKey()

    {

        /**

         * Fixed #4501142: Classloader sharing policy doesn't

         * take "archive" into account. This will be overridden

         * by Java Plug-in.                     [stanleyh]

         */

        return getCodeBase().toString();

    }

    /**

     * The class loaders

     */

    private static HashMap<String, AppletClassLoader> classloaders = new HashMap<>();

    /**

     * Flush a class loader.

     */

    public static synchronized void flushClassLoader(String key) {

        classloaders.remove(key);

    }

    /**

     * Flush all class loaders.

     */

    public static synchronized void flushClassLoaders() {

        classloaders = new HashMap<>();

    }

    /**

     * This method actually creates an AppletClassLoader.

     *

     * It can be override by subclasses (such as the Plug-in)

     * to provide different classloaders.

     */

    protected AppletClassLoader createClassLoader(final URL codebase) {

        return new AppletClassLoader(codebase);

    }

    /**

     * Get a class loader. Create in a restricted context

     */

    synchronized AppletClassLoader getClassLoader(final URL codebase, final String key) {

        AppletClassLoader c = classloaders.get(key);

        if (c == null) {

            AccessControlContext acc =

                getAccessControlContext(codebase);

            c = AccessController.doPrivileged(

                    new PrivilegedAction<AppletClassLoader>() {

                        @Override

                        public AppletClassLoader run() {

                            AppletClassLoader ac = createClassLoader(codebase);

                            /* Should the creation of the classloader be

                             * within the class synchronized block?  Since

                             * this class is used by the plugin, take care

                             * to avoid deadlocks, or specialize

                             * AppletPanel within the plugin.  It may take

                             * an arbitrary amount of time to create a

                             * class loader (involving getting Jar files

                             * etc.) and may block unrelated applets from

                             * finishing createAppletThread (due to the

                             * class synchronization). If

                             * createAppletThread does not finish quickly,

                             * the applet cannot process other messages,

                             * particularly messages such as destroy

                             * (which timeout when called from the browser).

                             */

                            synchronized (getClass()) {

                                AppletClassLoader res = classloaders.get(key);

                                if (res == null) {

                                    classloaders.put(key, ac);

                                    return ac;

                                } else {

                                    return res;

                                }

                            }

                        }

                    },acc);

        }

        return c;

    }

    /**

     * get the context for the AppletClassLoader we are creating.

     * the context is granted permission to create the class loader,

     * connnect to the codebase, and whatever else the policy grants

     * to all codebases.

     */

    private AccessControlContext getAccessControlContext(final URL codebase) {

        PermissionCollection perms = AccessController.doPrivileged(

                new PrivilegedAction<PermissionCollection>() {

                    @Override

                    public PermissionCollection run() {

                        Policy p = java.security.Policy.getPolicy();

                        if (p != null) {

                            return p.getPermissions(new CodeSource(null,

                                                                   (java.security.cert.Certificate[]) null));

                        } else {

                            return null;

                        }

                    }

                });

        if (perms == null)

            perms = new Permissions();

        //XXX: this is needed to be able to create the classloader itself!

        perms.add(SecurityConstants.CREATE_CLASSLOADER_PERMISSION);

        Permission p;

        java.net.URLConnection urlConnection = null;

        try {

            urlConnection = codebase.openConnection();

            p = urlConnection.getPermission();

        } catch (java.io.IOException ioe) {

            p = null;

        }

        if (p != null)

            perms.add(p);

        if (p instanceof FilePermission) {

            String path = p.getName();

            int endIndex = path.lastIndexOf(File.separatorChar);

            if (endIndex != -1) {

                path = path.substring(0, endIndex+1);

                if (path.endsWith(File.separator)) {

                    path += "-";

                }

                perms.add(new FilePermission(path,

                                             SecurityConstants.FILE_READ_ACTION));

            }

        } else {

            URL locUrl = codebase;

            if (urlConnection instanceof JarURLConnection) {

                locUrl = ((JarURLConnection)urlConnection).getJarFileURL();

            }

            String host = locUrl.getHost();

            if (host != null && (host.length() > 0))

                perms.add(new SocketPermission(host,

                                               SecurityConstants.SOCKET_CONNECT_ACCEPT_ACTION));

        }

        ProtectionDomain domain =

            new ProtectionDomain(new CodeSource(codebase,

                                                (java.security.cert.Certificate[]) null), perms);

        AccessControlContext acc =

            new AccessControlContext(new ProtectionDomain[] { domain });

        return acc;

    }

    public Thread getAppletHandlerThread() {

        return handler;

    }

    public int getAppletWidth() {

        return currentAppletSize.width;

    }

    public int getAppletHeight() {

        return currentAppletSize.height;

    }

    public static void changeFrameAppContext(Frame frame, AppContext newAppContext)

    {

        // Fixed #4754451: Applet can have methods running on main

        // thread event queue.

        //

        // The cause of this bug is that the frame of the applet

        // is created in main thread group. Thus, when certain

        // AWT/Swing events are generated, the events will be

        // dispatched through the wrong event dispatch thread.

        //

        // To fix this, we rearrange the AppContext with the frame,

        // so the proper event queue will be looked up.

        //

        // Swing also maintains a Frame list for the AppContext,

        // so we will have to rearrange it as well.

        // Check if frame's AppContext has already been set properly

        AppContext oldAppContext = SunToolkit.targetToAppContext(frame);

        if (oldAppContext == newAppContext)

            return;

        // Synchronization on Window.class is needed for locking the

        // critical section of the window list in AppContext.

        synchronized (Window.class)

        {

            WeakReference<Window> weakRef = null;

            // Remove frame from the Window list in wrong AppContext

            {

                // Lookup current frame's AppContext

                @SuppressWarnings("unchecked")

                Vector<WeakReference<Window>> windowList =

                    (Vector<WeakReference<Window>>)oldAppContext.get(Window.class);

                if (windowList != null) {

                    for (WeakReference<Window> ref : windowList) {

                        if (ref.get() == frame) {

                            weakRef = ref;

                            break;

                        }

                    }

                    // Remove frame from wrong AppContext

                    if (weakRef != null)

                        windowList.remove(weakRef);

                }

            }

            // Put the frame into the applet's AppContext map

            SunToolkit.insertTargetMapping(frame, newAppContext);

            // Insert frame into the Window list in the applet's AppContext map

            {

                @SuppressWarnings("unchecked")

                Vector<WeakReference<Window>> windowList =

                    (Vector<WeakReference<Window>>)newAppContext.get(Window.class);

                if (windowList == null) {

                    windowList = new Vector<WeakReference<Window>>();

                    newAppContext.put(Window.class, windowList);

                }

                // use the same weakRef here as it is used elsewhere

                windowList.add(weakRef);

            }

        }

    }

    // Flag to indicate if applet is targeted for JDK 1.1.

    private boolean jdk11Applet = false;

    // Flag to indicate if applet is targeted for JDK 1.2.

    private boolean jdk12Applet = false;

    /**

     * Determine JDK level of an applet.

     */

    private void findAppletJDKLevel(Applet applet)

    {

        // To determine the JDK level of an applet, the

        // most reliable way is to check the major version

        // of the applet class file.

        // synchronized on applet class object, so calling from

        // different instances of the same applet will be

        // serialized.

        Class<?> appletClass = applet.getClass();

        synchronized(appletClass)  {

            // Determine if the JDK level of an applet has been

            // checked before.

            Boolean jdk11Target = loader.isJDK11Target(appletClass);

            Boolean jdk12Target = loader.isJDK12Target(appletClass);

            // if applet JDK level has been checked before, retrieve

            // value and return.

            if (jdk11Target != null || jdk12Target != null) {

                jdk11Applet = (jdk11Target == null) ? false : jdk11Target.booleanValue();

                jdk12Applet = (jdk12Target == null) ? false : jdk12Target.booleanValue();

                return;

            }

            String name = appletClass.getName();

            // first convert any '.' to '/'

            name = name.replace('.', '/');

            // append .class

            final String resourceName = name + ".class";

            byte[] classHeader = new byte[8];

            try (InputStream is = AccessController.doPrivileged(

                    (PrivilegedAction<InputStream>) () -> loader.getResourceAsStream(resourceName))) {

                // Read the first 8 bytes of the class file

                int byteRead = is.read(classHeader, 0, 8);

                // return if the header is not read in entirely

                // for some reasons.

                if (byteRead != 8)

                    return;

            }

            catch (IOException e)   {

                return;

            }

            // Check major version in class file header

            int major_version = readShort(classHeader, 6);

            // Major version in class file is as follows:

            //   45 - JDK 1.1

            //   46 - JDK 1.2

            //   47 - JDK 1.3

            //   48 - JDK 1.4

            //   49 - JDK 1.5

            if (major_version < 46)

                jdk11Applet = true;

            else if (major_version == 46)

                jdk12Applet = true;

            // Store applet JDK level in AppContext for later lookup,

            // e.g. page switch.

            loader.setJDK11Target(appletClass, jdk11Applet);

            loader.setJDK12Target(appletClass, jdk12Applet);

        }

    }

    /**

     * Return true if applet is targeted to JDK 1.1.

     */

    protected boolean isJDK11Applet()   {

        return jdk11Applet;

    }

    /**

     * Return true if applet is targeted to JDK1.2.

     */

    protected boolean isJDK12Applet()   {

        return jdk12Applet;

    }

    /**

     * Read short from byte array.

     */

    private int readShort(byte[] b, int off)    {

        int hi = readByte(b[off]);

        int lo = readByte(b[off + 1]);

        return (hi << 8) | lo;

    }

    private int readByte(byte b) {

        return ((int)b) & 0xFF;

    }

    private static AppletMessageHandler amh = new AppletMessageHandler("appletpanel");

}

-- /dev/null

/*

 * Copyright (c) 1997, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.util.EventListener;

/**

 * Applet Listener interface.  This interface is to be implemented

 * by objects interested in AppletEvents.

 *

 * @author  Sunita Mani

 *

 * @deprecated The Applet API is deprecated. See the

 * <a href="../../java/applet/package-summary.html"> java.applet package

 * documentation</a> for further information.

 */

@Deprecated(since = "9")

public interface AppletListener extends EventListener {

    public void appletStateChanged(AppletEvent e);

}

-- /dev/null

/*

 * Copyright (c) 1997, 2014, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.util.EventObject;

/**

 * AppletEvent class.

 *

 * @author  Sunita Mani

 *

 * @deprecated The Applet API is deprecated. See the

 * <a href="../../java/applet/package-summary.html"> java.applet package

 * documentation</a> for further information.

 */

@SuppressWarnings("serial") // JDK-implementation class

@Deprecated(since = "9")

public class AppletEvent extends EventObject {

    private Object arg;

    private int id;

    public AppletEvent(Object source, int id, Object argument) {

        super(source);

        this.arg = argument;

        this.id = id;

    }

    public int getID() {

        return id;

    }

    public Object getArgument() {

        return arg;

    }

    public String toString() {

        String str = getClass().getName() + "[source=" + source + " + id="+ id;

        if (arg != null) {

            str += " + arg=" + arg;

        }

        str += " ]";

        return str;

    }

}

-- /dev/null

/*

 * Copyright (c) 1996, 2014, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.util.ResourceBundle;

import java.util.MissingResourceException;

import java.text.MessageFormat;

/**

 * An hanlder of localized messages.

 *

 * @author      Koji Uno

 */

class AppletMessageHandler {

    private static ResourceBundle rb;

    private String baseKey = null;

    static {

        try {

            rb = ResourceBundle.getBundle

                ("sun.applet.resources.MsgAppletViewer");

        } catch (MissingResourceException e) {

            System.out.println(e.getMessage());

            System.exit(1);

        }

    }

    AppletMessageHandler(String baseKey) {

        this.baseKey = baseKey;

    }

    String getMessage(String key) {

        return rb.getString(getQualifiedKey(key));

    }

    String getMessage(String key, Object arg){

        String basemsgfmt = rb.getString(getQualifiedKey(key));

        MessageFormat msgfmt = new MessageFormat(basemsgfmt);

        Object msgobj[] = new Object[1];

        if (arg == null) {

            arg = "null"; // mimic java.io.PrintStream.print(String)

        }

        msgobj[0] = arg;

        return msgfmt.format(msgobj);

    }

    String getMessage(String key, Object arg1, Object arg2) {

        String basemsgfmt = rb.getString(getQualifiedKey(key));

        MessageFormat msgfmt = new MessageFormat(basemsgfmt);

        Object msgobj[] = new Object[2];

        if (arg1 == null) {

            arg1 = "null";

        }

        if (arg2 == null) {

            arg2 = "null";

        }

        msgobj[0] = arg1;

        msgobj[1] = arg2;

        return msgfmt.format(msgobj);

    }

    String getMessage(String key, Object arg1, Object arg2, Object arg3) {

        String basemsgfmt = rb.getString(getQualifiedKey(key));

        MessageFormat msgfmt = new MessageFormat(basemsgfmt);

        Object msgobj[] = new Object[3];

        if (arg1 == null) {

            arg1 = "null";

        }

        if (arg2 == null) {

            arg2 = "null";

        }

        if (arg3 == null) {

            arg3 = "null";

        }

        msgobj[0] = arg1;

        msgobj[1] = arg2;

        msgobj[2] = arg3;

        return msgfmt.format(msgobj);

    }

    String getMessage(String key, Object arg[]) {

        String basemsgfmt = rb.getString(getQualifiedKey(key));

        MessageFormat msgfmt = new MessageFormat(basemsgfmt);

        return msgfmt.format(arg);

    }

    String getQualifiedKey(String subKey) {

        return baseKey + "." + subKey;

    }

}

-- icedtea-web.orig/netx/net/sourceforge/jnlp/runtime/JNLPSecurityManager.java

/*

 * Copyright (c) 1997, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.applet;

import java.util.EventListener;

import java.io.Serializable;

import java.io.ObjectOutputStream;

import java.io.IOException;

/**

 * AppletEventMulticaster class.  This class manages an immutable

 * structure consisting of a chain of AppletListeners and is

 * responsible for dispatching events to them.

 *

 * @author  Sunita Mani

 *

 * @deprecated The Applet API is deprecated. See the

 * <a href="../../java/applet/package-summary.html"> java.applet package

 * documentation</a> for further information.

 */

@Deprecated(since = "9")

public class AppletEventMulticaster implements AppletListener {

    private final AppletListener a, b;

    public AppletEventMulticaster(AppletListener a, AppletListener b) {

        this.a = a; this.b = b;

    }

    public void appletStateChanged(AppletEvent e) {

        a.appletStateChanged(e);

        b.appletStateChanged(e);

    }

    /**

     * Adds Applet-listener-a with Applet-listener-b and

     * returns the resulting multicast listener.

     * @param a Applet-listener-a

     * @param b Applet-listener-b

     */

    public static AppletListener add(AppletListener a, AppletListener b) {

        return addInternal(a, b);

    }

    /**

     * Removes the old Applet-listener from Applet-listener-l and

     * returns the resulting multicast listener.

     * @param l Applet-listener-l

     * @param oldl the Applet-listener being removed

     */

    public static AppletListener remove(AppletListener l, AppletListener oldl) {

        return removeInternal(l, oldl);

    }

    /**

     * Returns the resulting multicast listener from adding listener-a

     * and listener-b together.

     * If listener-a is null, it returns listener-b;

     * If listener-b is null, it returns listener-a

     * If neither are null, then it creates and returns

     * a new AppletEventMulticaster instance which chains a with b.

     * @param a event listener-a

     * @param b event listener-b

     */

    private static AppletListener addInternal(AppletListener a, AppletListener b) {

        if (a == null)  return b;

        if (b == null)  return a;

        return new AppletEventMulticaster(a, b);

    }

    /**

     * Removes a listener from this multicaster and returns the

     * resulting multicast listener.

     * @param oldl the listener to be removed

     */

    protected AppletListener remove(AppletListener oldl) {

        if (oldl == a)  return b;

        if (oldl == b)  return a;

        AppletListener a2 = removeInternal(a, oldl);

        AppletListener b2 = removeInternal(b, oldl);

        if (a2 == a && b2 == b) {

            return this;        // it's not here

        }

        return addInternal(a2, b2);

    }

    /**

     * Returns the resulting multicast listener after removing the

     * old listener from listener-l.

     * If listener-l equals the old listener OR listener-l is null,

     * returns null.