diff options
Diffstat (limited to '')
19 files changed, 3003 insertions, 0 deletions
diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/GREVersionRange.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/GREVersionRange.java new file mode 100644 index 00000000..ede1a523 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/GREVersionRange.java @@ -0,0 +1,80 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2005 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + + +public class GREVersionRange { + + private String lower; + private boolean lowerInclusive; + private String upper; + private boolean upperInclusive; + + public GREVersionRange(String aLower, boolean aLowerInclusive, + String aUpper, boolean aUpperInclusive) { + lower = aLower; + lowerInclusive = aLowerInclusive; + upper = aUpper; + upperInclusive = aUpperInclusive; + } + + public boolean check(String aVersion) { + VersionComparator comparator = new VersionComparator(); + int c = comparator.compare(aVersion, lower); + if (c < 0) { + return false; + } + + if (c == 0 && !lowerInclusive) { + return false; + } + + c = comparator.compare(aVersion, upper); + if (c > 0) { + return false; + } + + if (c == 0 && !upperInclusive) { + return false; + } + + return true; + } + +} + diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IAppFileLocProvider.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IAppFileLocProvider.java new file mode 100644 index 00000000..633d8bbc --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IAppFileLocProvider.java @@ -0,0 +1,92 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2004 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.File; + + +/** + * Used by XPCOM's Directory Service to get file locations. + * <p> + * This interface is similar to <code>nsIDirectoryServiceProvider</code> and + * <code>nsIDirectoryServiceProvider2</code>, except that its methods use + * <code>java.io.File</code> instead of <code>nsIFile</code>. + * </p> + * + * @see Mozilla#initEmbedding + * @see Mozilla#initXPCOM + * @see <a href= + * "http://lxr.mozilla.org/mozilla/source/xpcom/io/nsIDirectoryService.idl"> + * nsIDirectoryServiceProvider </a> + * @see <a href= + * "http://lxr.mozilla.org/mozilla/source/xpcom/io/nsDirectoryServiceDefs.h"> + * Directory Service property names </a> + */ +public interface IAppFileLocProvider { + + /** + * Directory Service calls this when it gets the first request for + * a property or on every request if the property is not persistent. + * + * @param prop the symbolic name of the file + * @param persistent an array of length one used to supply the output value: + * <ul> + * <li><code>true</code> - The returned file will be + * cached by Directory Service. Subsequent requests for + * this prop will bypass the provider and use the cache. + * </li> + * <li><code>false</code> - The provider will be asked + * for this prop each time it is requested. </li> + * </ul> + * + * @return the file represented by the property + */ + File getFile(String prop, boolean[] persistent); + + /** + * Directory Service calls this when it gets a request for + * a property and the requested type is nsISimpleEnumerator. + * + * @param prop the symbolic name of the file list + * + * @return an array of file locations + */ + File[] getFiles(String prop); + +} + diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IGRE.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IGRE.java new file mode 100644 index 00000000..ecf000fe --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IGRE.java @@ -0,0 +1,127 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.File; + + +public interface IGRE { + + /** + * Initializes libXUL for embedding purposes. + * <p> + * NOTE: This function must be called from the "main" thread. + * <p> + * NOTE: At the present time, this function may only be called once in + * a given process. Use <code>termEmbedding</code> to clean up and free + * resources allocated by <code>initEmbedding</code>. + * + * @param aLibXULDirectory The directory in which the libXUL shared library + * was found. + * @param aAppDirectory The directory in which the application components + * and resources can be found. This will map to + * the "resource:app" directory service key. + * @param aAppDirProvider A directory provider for the application. This + * provider will be aggregated by a libXUL provider + * which will provide the base required GRE keys. + * + * @throws XPCOMException if a failure occurred during initialization + */ + void initEmbedding(File aLibXULDirectory, File aAppDirectory, + IAppFileLocProvider aAppDirProvider) throws XPCOMException; + + /** + * Terminates libXUL embedding. + * <p> + * NOTE: Release any references to XPCOM objects that you may be holding + * before calling this function. + */ + void termEmbedding(); + + /** + * Lock a profile directory using platform-specific semantics. + * + * @param aDirectory The profile directory to lock. + * + * @return A lock object. The directory will remain locked until the lock is + * released by invoking the <code>release</code> method, or by the + * termination of the JVM, whichever comes first. + * + * @throws XPCOMException if a failure occurred + */ + ProfileLock lockProfileDirectory(File aDirectory) throws XPCOMException; + + /** + * Fire notifications to inform the toolkit about a new profile. This + * method should be called after <code>initEmbedding</code> if the + * embedder wishes to run with a profile. + * <p> + * Normally the embedder should call <code>lockProfileDirectory</code> + * to lock the directory before calling this method. + * <p> + * NOTE: There are two possibilities for selecting a profile: + * <ul> + * <li> + * Select the profile before calling <code>initEmbedding</code>. + * The aAppDirProvider object passed to <code>initEmbedding</code> + * should provide the NS_APP_USER_PROFILE_50_DIR key, and + * may also provide the following keys: + * <ul> + * <li>NS_APP_USER_PROFILE_LOCAL_50_DIR + * <li>NS_APP_PROFILE_DIR_STARTUP + * <li>NS_APP_PROFILE_LOCAL_DIR_STARTUP + * </ul> + * In this scenario <code>notifyProfile</code> should be called + * immediately after <code>initEmbedding</code>. Component + * registration information will be stored in the profile and + * JS components may be stored in the fastload cache. + * </li> + * <li> + * Select a profile some time after calling <code>initEmbedding</code>. + * In this case the embedder must install a directory service + * provider which provides NS_APP_USER_PROFILE_50_DIR and optionally + * NS_APP_USER_PROFILE_LOCAL_50_DIR. Component registration information + * will be stored in the application directory and JS components will not + * fastload. + * </li> + * </ul> + */ + void notifyProfile(); + +} + + diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IJavaXPCOMUtils.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IJavaXPCOMUtils.java new file mode 100644 index 00000000..7b70caf9 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IJavaXPCOMUtils.java @@ -0,0 +1,59 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2007 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +public interface IJavaXPCOMUtils { + + /** + * Returns a pointer to a C++ proxy object for the given Java object. + * + * @param aJavaObject Java object to encapsulate in C++ proxy + * @param aIID interface ID for requested proxy + * @return C pointer (as long) of new proxy + */ + long wrapJavaObject(Object aJavaObject, String aIID); + + /** + * Returns a Java proxy for the given C++ XPCOM object + * + * @param aXPCOMObject C++ XPCOM object to encapsulate in Java proxy + * @param aIID interface ID for requested proxy + * @return new Proxy + */ + Object wrapXPCOMObject(long aXPCOMObject, String aIID); + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IMozilla.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IMozilla.java new file mode 100644 index 00000000..b148e9a2 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IMozilla.java @@ -0,0 +1,63 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.File; + +public interface IMozilla { + + /** + * Initialize the Mozilla object with the given XULRunner path. All + * subsequent Mozilla method invocations be done against the given XULRunner + * version. + * + * @param aLibXULDirectory path of XULRunner build to use + * + * @throws XPCOMInitializationException if failure occurred during + * initialization + */ + void initialize(File aLibXULDirectory) throws XPCOMInitializationException; + + /** + * Return the native window handle for an AWT component. + * + * @param widget An AWT component (such as Canvas, Frame) that is backed by + * a real native window. + * @return the pointer to the native window (platform specific) + */ + long getNativeHandleFromAWT(Object widget); +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/INIParser.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/INIParser.java new file mode 100644 index 00000000..ba2f11c7 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/INIParser.java @@ -0,0 +1,243 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2005 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.charset.Charset; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Properties; +import java.util.StringTokenizer; + + +/** + * A simple parser for INI files. + */ +public class INIParser { + + private HashMap<String, Properties> mSections; + + /** + * Creates a new <code>INIParser</code> instance from the INI file at the + * given path. <code>aCharset</code> specifies the character encoding of + * the file. + * + * @param aFilename path of INI file to parse + * @param aCharset character encoding of file + * @throws FileNotFoundException if <code>aFilename</code> does not exist. + * @throws IOException if there is a problem reading the given file. + */ + public INIParser(String aFilename, Charset aCharset) + throws FileNotFoundException, IOException { + initFromFile(new File(aFilename), aCharset); + } + + /** + * Creates a new <code>INIParser</code> instance from the INI file at the + * given path, which is assumed to be in the <code>UTF-8</code> charset. + * + * @param aFilename path of INI file to parse + * @throws FileNotFoundException if <code>aFilename</code> does not exist. + * @throws IOException if there is a problem reading the given file. + */ + public INIParser(String aFilename) throws FileNotFoundException, IOException { + initFromFile(new File(aFilename), Charset.forName("UTF-8")); + } + + /** + * Creates a new <code>INIParser</code> instance from the given file. + * <code>aCharset</code> specifies the character encoding of the file. + * + * @param aFile INI file to parse + * @param aCharset character encoding of file + * @throws FileNotFoundException if <code>aFile</code> does not exist. + * @throws IOException if there is a problem reading the given file. + */ + public INIParser(File aFile, Charset aCharset) + throws FileNotFoundException, IOException { + initFromFile(aFile, aCharset); + } + + /** + * Creates a new <code>INIParser</code> instance from the given file, + * which is assumed to be in the <code>UTF-8</code> charset. + * + * @param aFile INI file to parse + * @throws FileNotFoundException if <code>aFile</code> does not exist. + * @throws IOException if there is a problem reading the given file. + */ + public INIParser(File aFile) throws FileNotFoundException, IOException { + initFromFile(aFile, Charset.forName("UTF-8")); + } + + /** + * Parses given INI file. + * + * @param aFile INI file to parse + * @param aCharset character encoding of file + * @throws FileNotFoundException if <code>aFile</code> does not exist. + * @throws IOException if there is a problem reading the given file. + */ + private void initFromFile(File aFile, Charset aCharset) + throws FileNotFoundException, IOException { + FileInputStream fileStream = new FileInputStream(aFile); + InputStreamReader inStream = new InputStreamReader(fileStream, aCharset); + BufferedReader reader = new BufferedReader(inStream); + + mSections = new HashMap<String, Properties>(); + String currSection = null; + + String line; + while ((line = reader.readLine()) != null) { + // skip empty lines and comment lines + String trimmedLine = line.trim(); + if (trimmedLine.length() == 0 || trimmedLine.startsWith("#") + || trimmedLine.startsWith(";")) { + continue; + } + + // Look for section headers (i.e. "[Section]"). + if (line.startsWith("[")) { + /* + * We are looking for a well-formed "[Section]". If this header is + * malformed (i.e. "[Section" or "[Section]Moretext"), just skip it + * and go on to next well-formed section header. + */ + if (!trimmedLine.endsWith("]") || + trimmedLine.indexOf("]") != (trimmedLine.length() - 1)) { + currSection = null; + continue; + } + + // remove enclosing brackets + currSection = trimmedLine.substring(1, trimmedLine.length() - 1); + continue; + } + + // If we haven't found a valid section header, continue to next line + if (currSection == null) { + continue; + } + + StringTokenizer tok = new StringTokenizer(line, "="); + if (tok.countTokens() != 2) { // looking for value pairs + continue; + } + + Properties props = mSections.get(currSection); + if (props == null) { + props = new Properties(); + mSections.put(currSection, props); + } + props.setProperty(tok.nextToken(), tok.nextToken()); + } + + reader.close(); + } + + /** + * Returns an iterator over the section names available in the INI file. + * + * @return an iterator over the section names + */ + public Iterator getSections() { + return mSections.keySet().iterator(); + } + + /** + * Returns an iterator over the keys available within a section. + * + * @param aSection section name whose keys are to be returned + * @return an iterator over section keys, or <code>null</code> if no + * such section exists + */ + public Iterator getKeys(String aSection) { + /* + * Simple wrapper class to convert Enumeration to Iterator + */ + class PropertiesIterator implements Iterator { + private Enumeration e; + + public PropertiesIterator(Enumeration aEnum) { + e = aEnum; + } + + public boolean hasNext() { + return e.hasMoreElements(); + } + + public Object next() { + return e.nextElement(); + } + + public void remove() { + return; + } + } + + Properties props = mSections.get(aSection); + if (props == null) { + return null; + } + + return new PropertiesIterator(props.propertyNames()); + } + + /** + * Gets the string value for a particular section and key. + * + * @param aSection a section name + * @param aKey the key whose value is to be returned. + * @return string value of particular section and key + */ + public String getString(String aSection, String aKey) { + Properties props = mSections.get(aSection); + if (props == null) { + return null; + } + + return props.getProperty(aKey); + } + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IXPCOM.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IXPCOM.java new file mode 100644 index 00000000..8cfbfb30 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IXPCOM.java @@ -0,0 +1,137 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.File; + +import org.mozilla.interfaces.nsIComponentManager; +import org.mozilla.interfaces.nsIComponentRegistrar; +import org.mozilla.interfaces.nsILocalFile; +import org.mozilla.interfaces.nsIServiceManager; + + +public interface IXPCOM { + + /** + * Initializes XPCOM. You must call this method before proceeding + * to use XPCOM. + * + * @param aMozBinDirectory The directory containing the component + * registry and runtime libraries; + * or use <code>null</code> to use the working + * directory. + * + * @param aAppFileLocProvider The object to be used by Gecko that specifies + * to Gecko where to find profiles, the component + * registry preferences and so on; or use + * <code>null</code> for the default behaviour. + * + * @return the service manager + * + * @throws XPCOMException <ul> + * <li> NS_ERROR_NOT_INITIALIZED - if static globals were not initialied, + * which can happen if XPCOM is reloaded, but did not completly + * shutdown. </li> + * <li> Other error codes indicate a failure during initialisation. </li> + * </ul> + */ + nsIServiceManager initXPCOM(File aMozBinDirectory, + IAppFileLocProvider aAppFileLocProvider) throws XPCOMException; + + /** + * Shutdown XPCOM. You must call this method after you are finished + * using xpcom. + * + * @param aServMgr The service manager which was returned by initXPCOM. + * This will release servMgr. + * + * @throws XPCOMException if a failure occurred during termination + */ + void shutdownXPCOM(nsIServiceManager aServMgr) throws XPCOMException; + + /** + * Public Method to access to the service manager. + * + * @return the service manager + * + * @throws XPCOMException + */ + nsIServiceManager getServiceManager() throws XPCOMException; + + /** + * Public Method to access to the component manager. + * + * @return the component manager + * + * @throws XPCOMException + */ + nsIComponentManager getComponentManager() throws XPCOMException; + + /** + * Public Method to access to the component registration manager. + * + * @return the component registration manager + * + * @throws XPCOMException + */ + nsIComponentRegistrar getComponentRegistrar() throws XPCOMException; + + /** + * Public Method to create an instance of a nsILocalFile. + * + * @param aPath A string which specifies a full file path to a + * location. Relative paths will be treated as an + * error (NS_ERROR_FILE_UNRECOGNIZED_PATH). + * @param aFollowLinks This attribute will determine if the nsLocalFile will + * auto resolve symbolic links. By default, this value + * will be false on all non unix systems. On unix, this + * attribute is effectively a noop. + * + * @return an instance of an nsILocalFile that points to given path + * + * @throws XPCOMException <ul> + * <li> NS_ERROR_FILE_UNRECOGNIZED_PATH - raised for unrecognized paths + * or relative paths (must supply full file path) </li> + * </ul> + */ + nsILocalFile newLocalFile(String aPath, boolean aFollowLinks) + throws XPCOMException; + + // #ifdef VBOX + int waitForEvents(long timeout); + // #endif VBOX +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/Mozilla.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/Mozilla.java new file mode 100644 index 00000000..05314c90 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/Mozilla.java @@ -0,0 +1,1079 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.Properties; + +import org.mozilla.interfaces.nsIComponentManager; +import org.mozilla.interfaces.nsIComponentRegistrar; +import org.mozilla.interfaces.nsILocalFile; +import org.mozilla.interfaces.nsIServiceManager; +import org.mozilla.interfaces.nsISupports; + + +/** + * A singleton class which provides access to the Mozilla browser. Requires + * that XULRunner be installed on the user's system. + * <p> + * You would use to class to find a XULRunner installation, setup a profile (if + * necessary), and initialize embedding. A typical scenario would look like + * this: + * </p><pre> + * Mozilla mozilla = Mozilla.getInstance(); + * GREVersionRange[] range = new GREVersionRange[1]; + * range[0] = new GREVersionRange("1.8.0.*", false, "1.8.1.*", true); + * try { + * File grePath = Mozilla.getGREPathWithProperties(range, null); + * mozilla.initialize(grePath); + * profLock = mozilla.lockProfileDirectory(profileDir); + * // LocationProvider is a user class that implements IAppFileLocProvider + * LocationProvider locProvider = new LocationProvider(grePath, profileDir); + * mozilla.initEmbedding(grePath, grePath, locProvider); + * mozilla.notifyProfile(); + * } catch (XPCOMInitializationException xie) { + * // handle exception + * } catch (XPCOMException xe) { + * // handle exception + * } + * </pre> + * + * @see http://www.mozilla.org/projects/embedding/GRE.html + */ +public class Mozilla implements IMozilla, IGRE, IXPCOM, IJavaXPCOMUtils,XPCOMError { + + private static Mozilla mozillaInstance = new Mozilla(); + + private static final String JAVAXPCOM_JAR = "vboxjxpcom.jar"; + + private IMozilla mozilla = null; + private IGRE gre = null; + private IXPCOM xpcom = null; + private IJavaXPCOMUtils jxutils = null; + + /** + * @return + */ + public static Mozilla getInstance() { + return mozillaInstance; + } + + /** + * + */ + private Mozilla() { + } + + /** + * Locates the path of a GRE with the specified properties. This method + * will only return GREs that support Java embedding (looks for the + * presence of "javaxpcom.jar"). + * <p> + * Currently this uses a "first-fit" algorithm, it does not select + * the newest available GRE. + * + * @param aVersions An array of version ranges: if any version range + * matches, the GRE is considered acceptable. + * @param aProperties A list of GRE property/value pairs which must + * all be satisfied. This parameter is ignored on + * Macintosh, because of the manner in which the + * XUL frameworks are installed. + * + * @return A file object of the appropriate path. If + * the "local" GRE is specified (via the USE_LOCAL_GRE + * environment variable, for example), returns + * <code>null</code>. + * + * @throws FileNotFoundException if an appropriate GRE could not be found + */ + public static File getGREPathWithProperties(GREVersionRange[] aVersions, + Properties aProperties) throws FileNotFoundException { + File grePath = null; + + // if GRE_HOME is in the environment, use that GRE + String env = System.getProperty("GRE_HOME"); + if (env != null) { + try { + grePath = new File(env).getCanonicalFile(); + } catch (IOException e) { + throw new FileNotFoundException("cannot access GRE_HOME"); + } + if (!grePath.exists()) { + throw new FileNotFoundException("GRE_HOME doesn't exist"); + } + return grePath; + } + + // the Gecko bits that sit next to the application or in the PATH + env = System.getProperty("USE_LOCAL_GRE"); + if (env != null) { + return null; + } + + // Search for GRE in platform specific locations. We want a GRE that + // supports Java, so we look for the "javaxpcom" property by default. + if (aProperties == null) { + aProperties = new Properties(); + } + aProperties.setProperty("javaxpcom", "1"); + + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.startsWith("mac os x")) { + grePath = getGREPathMacOSX(aVersions); + } else if (osName.startsWith("windows")) { + grePath = getGREPathWindows(aVersions, aProperties); + } else { + // assume everything else is Unix/Linux + grePath = getGREPathUnix(aVersions, aProperties); + } + + if (grePath == null) { + throw new FileNotFoundException("GRE not found"); + } + + return grePath; + } + + /** + * @param aVersions + * @return + */ + private static File getGREPathMacOSX(GREVersionRange[] aVersions) { + /* + * Check the application bundle first, for + * <bundle>/Contents/Frameworks/XUL.framework/libxpcom.dylib. + */ + File grePath = findGREBundleFramework(); + if (grePath != null) { + return grePath; + } + + // Check ~/Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib + String home = System.getProperty("user.home"); + if (home != null) { + grePath = findGREFramework(home, aVersions); + if (grePath != null) { + return grePath; + } + } + + // Check /Library/Frameworks/XUL.framework/Versions/<version>/libxpcom.dylib + return findGREFramework("", aVersions); + } + + /** + * @return + */ + private static File findGREBundleFramework() { + /* + * Use reflection to get Apple's NSBundle class, which can be used + * to get the bundle's "Frameworks" directory. + */ + try { + URL[] urls = new URL[1]; + urls[0] = new File("/System/Library/Java/").toURI().toURL(); + ClassLoader loader = new URLClassLoader(urls); + Class<?> bundleClass = Class.forName("com.apple.cocoa.foundation.NSBundle", + true, loader); + + // Get the bundle for this app. If this is not executing from + // a bundle, this will return null. + Method mainBundleMethod = bundleClass.getMethod("mainBundle", (java.lang.Class[])null); + Object bundle = mainBundleMethod.invoke(null, (java.lang.Object[])null); + + if (bundle != null) { + // Get the path to the bundle's "Frameworks" directory + Method fwPathMethod = bundleClass.getMethod("privateFrameworksPath", + (java.lang.Class[])null); + String path = (String) fwPathMethod.invoke(bundle, (java.lang.Object[])null); + + // look for libxpcom.dylib + if (path.length() != 0) { + File xulDir = new File(path, "XUL.framework"); + if (xulDir.isDirectory()) { + File xpcomLib = new File(xulDir, "libxpcom.dylib"); + if (xpcomLib.canRead()) { + File grePath = xpcomLib.getCanonicalFile().getParentFile(); + + // Since GRE Properties aren't supported on Mac OS X, we check + // for the existence of the "javaxpcom.jar" file in the GRE. + File jar = new File(grePath, JAVAXPCOM_JAR); + if (jar.canRead()) { + // found GRE + return grePath; + } + } + } + } + } + } catch (Exception e) { } + + return null; + } + + /** + * @param aRootPath + * @param aVersions + * @return + */ + private static File findGREFramework(String aRootPath, + GREVersionRange[] aVersions) { + File frameworkDir = new File(aRootPath + + "/Library/Frameworks/XUL.framework/Versions"); + if (!frameworkDir.exists()) + return null; + + File[] files = frameworkDir.listFiles(); + for (int i = 0; i < files.length; i++) { + if (checkVersion(files[i].getName(), aVersions)) { + File xpcomLib = new File(files[i], "libxpcom.dylib"); + + // Since GRE Properties aren't supported on Mac OS X, we check + // for the existence of the "javaxpcom.jar" file in the GRE. + File jar = new File(files[i], JAVAXPCOM_JAR); + if (xpcomLib.canRead() && jar.canRead()) { + return files[i]; + } + } + } + + return null; + } + + /** + * @param aVersions + * @param aProperties + * @return + */ + private static File getGREPathWindows(GREVersionRange[] aVersions, + Properties aProperties) { + /* + * Note the usage of the "Software\\mozilla.org\\GRE" subkey - this allows + * us to have multiple versions of GREs on the same machine by having + * subkeys such as 1.0, 1.1, 2.0 etc. under it. + * + * Please see http://www.mozilla.org/projects/embedding/GRE.html for + * more info. + */ + + final String greKey = "Software\\mozilla.org\\GRE"; + + // See if there is a GRE registered for the current user. + // If not, look for one on the system. + String key = "HKEY_CURRENT_USER" + "\\" + greKey; + File grePath = getGREPathFromRegKey(key, aVersions, aProperties); + if (grePath == null) { + key = "HKEY_LOCAL_MACHINE" + "\\" + greKey; + grePath = getGREPathFromRegKey(key, aVersions, aProperties); + } + + return grePath; + } + + /** + * @param aRegKey + * @param aVersions + * @param aProperties + * @return + */ + private static File getGREPathFromRegKey(String aRegKey, + GREVersionRange[] aVersions, Properties aProperties) { + // create a temp file for the registry export + File tempFile; + try { + tempFile = File.createTempFile("jx_registry", null); + } catch (IOException e) { + // failed to create temp file. ABORT + return null; + } + + Process proc; + try { + proc = Runtime.getRuntime().exec("regedit /e " + "\"" + tempFile.getPath() + + "\" \"" + aRegKey + "\""); + proc.waitFor(); + } catch (Exception e) { + // Failed to run regedit.exe. Length of temp file is zero, and that's + // handled next. + } + + // If there is a key by that name in the registry, then the file length + // will not be zero. + File grePath = null; + if (tempFile.length() != 0) { + grePath = getGREPathFromRegistryFile(tempFile.getPath(), + aRegKey, aVersions, aProperties); + } + + tempFile.delete(); + return grePath; + } + + /** + * @param aFileName + * @param aCharset + * @param aKeyName + * @param aVersions + * @param aProperties + * @return + */ + private static File getGREPathFromRegistryFile(String aFileName, + String aKeyName, GREVersionRange[] aVersions, + Properties aProperties) { + INIParser parser; + try { + parser = new INIParser(aFileName, Charset.forName("UTF-16")); + } catch (Exception e) { + // Problem reading from file. Bail out. + return null; + } + + Iterator sectionsIter = parser.getSections(); + while (sectionsIter.hasNext()) { + // get 'section' name, which will be a registry key name + String section = (String) sectionsIter.next(); + + // Skip over GRE key ("<root>\Software\mozilla.org\GRE") + int gre_len = aKeyName.length(); + if (section.length() <= gre_len) { + continue; + } + + // Get the GRE subkey; that is, everything after + // "<root>\Software\mozilla.org\GRE\" + String subkeyName = section.substring(gre_len + 1); + + // We are only interested in _immediate_ subkeys. We want + // "<root>\Software\mozilla.org\GRE\<version>" but not + // "<root>\Software\mozilla.org\GRE\<version>\<moretext>". + if (subkeyName.indexOf('\\') != -1) { + continue; + } + + // See if this registry key has a "Version" value, and if so, compare + // it to our desired versions. + String version = parser.getString(section, "\"Version\""); + if (version == null) { + continue; + } + // remove quotes around string + version = version.substring(1, version.length() - 1); + if (!checkVersion(version, aVersions)) { + continue; + } + + // All properties must match, keeping in mind that the propery/value + // pairs returned by regedit.exe have quotes around them. + if (aProperties != null) { + boolean ok = true; + Enumeration e = aProperties.propertyNames(); + while (ok && e.hasMoreElements()) { + String prop = (String) e.nextElement(); + String greValue = parser.getString(section, "\"" + prop + "\""); + if (greValue == null) { + // No such property is set for this GRE. Go on to next GRE. + ok = false; + } else { + // See if the value of the property for the GRE matches + // the given value. + String value = aProperties.getProperty(prop); + if (!greValue.equals("\"" + value + "\"")) { + ok = false; + } + } + } + if (!ok) { + continue; + } + } + + String pathStr = parser.getString(section, "\"GreHome\""); + if (pathStr != null) { + // remove quotes around string + pathStr = pathStr.substring(1, pathStr.length() - 1); + File grePath = new File(pathStr); + if (grePath.exists()) { + File xpcomLib = new File(grePath, "xpcom.dll"); + if (xpcomLib.canRead()) { + // found a good GRE + return grePath; + } + } + } + } + + return null; + } + + /** + * @param aVersions + * @param aProperties + * @return + */ + private static File getGREPathUnix(GREVersionRange[] aVersions, + Properties aProperties) { + File grePath = null; + + String env = System.getProperty("MOZ_GRE_CONF"); + if (env != null) { + grePath = getPathFromConfigFile(env, aVersions, aProperties); + if (grePath != null) { + return grePath; + } + } + + final String greUserConfFile = ".gre.config"; + final String greUserConfDir = ".gre.d"; + final String greConfPath = "/etc/gre.conf"; + final String greConfDir = "/etc/gre.d"; + + env = System.getProperty("user.home"); + if (env != null) { + // Look in ~/.gre.config + grePath = getPathFromConfigFile(env + File.separator + greUserConfFile, + aVersions, aProperties); + if (grePath != null) { + return grePath; + } + + // Look in ~/.gre.d/*.conf + grePath = getPathFromConfigDir(env + File.separator + greUserConfDir, + aVersions, aProperties); + if (grePath != null) { + return grePath; + } + } + + // Look for a global /etc/gre.conf file + grePath = getPathFromConfigFile(greConfPath, aVersions, aProperties); + if (grePath != null) { + return grePath; + } + + // Look for a group of config files in /etc/gre.d/ + grePath = getPathFromConfigDir(greConfDir, aVersions, aProperties); + return grePath; + } + + /** + * @param aFileName + * @param aVersions + * @param aProperties + * @return + */ + private static File getPathFromConfigFile(String aFileName, + GREVersionRange[] aVersions, Properties aProperties) { + INIParser parser; + try { + parser = new INIParser(aFileName); + } catch (Exception e) { + // Problem reading from file. Bail out. + return null; + } + + Iterator sectionsIter = parser.getSections(); + while (sectionsIter.hasNext()) { + // get 'section' name, which will be a version string + String section = (String) sectionsIter.next(); + + // if this isn't one of the versions we are looking for, move + // on to next section + if (!checkVersion(section, aVersions)) { + continue; + } + + // all properties must match + if (aProperties != null) { + boolean ok = true; + Enumeration e = aProperties.propertyNames(); + while (ok && e.hasMoreElements()) { + String prop = (String) e.nextElement(); + String greValue = parser.getString(section, prop); + if (greValue == null) { + // No such property is set for this GRE. Go on to next GRE. + ok = false; + } else { + // See if the value of the property for the GRE matches + // the given value. + if (!greValue.equals(aProperties.getProperty(prop))) { + ok = false; + } + } + } + if (!ok) { + continue; + } + } + + String pathStr = parser.getString(section, "GRE_PATH"); + if (pathStr != null) { + File grePath = new File(pathStr); + if (grePath.exists()) { + File xpcomLib = new File(grePath, "libxpcom.so"); + if (xpcomLib.canRead()) { + // found a good GRE + return grePath; + } + } + } + } + + return null; + } + + /** + * @param aDirName + * @param aVersions + * @param aProperties + * @return + */ + private static File getPathFromConfigDir(String aDirName, + GREVersionRange[] aVersions, Properties aProperties) { + /* + * Open the directory provided and try to read any files in that + * directory that end with .conf. We look for an entry that might + * point to the GRE that we're interested in. + */ + + File dir = new File(aDirName); + if (!dir.isDirectory()) { + return null; + } + + File grePath = null; + File[] files = dir.listFiles(); + for (int i = 0; i < files.length && grePath == null; i++) { + // only look for files that end in '.conf' + if (!files[i].getName().endsWith(".conf")) { + continue; + } + + grePath = getPathFromConfigFile(files[i].getPath(), aVersions, + aProperties); + } + + return grePath; + } + + /** + * @param aVersionToCheck + * @param aVersions + * @return + */ + private static boolean checkVersion(String aVersionToCheck, + GREVersionRange[] aVersions) { + for (int i = 0; i < aVersions.length; i++) { + if (aVersions[i].check(aVersionToCheck)) { + return true; + } + } + return false; + } + + /** + * Initialize the Mozilla object with the given XULRunner path. All + * subsequent Mozilla method invocations be done against the given XULRunner + * version. + * + * @param aLibXULDirectory path of XULRunner build to use + * + * @throws XPCOMInitializationException if failure occurred during + * initialization + */ + public void initialize(File aLibXULDirectory) + throws XPCOMInitializationException { + File jar = new File(aLibXULDirectory, JAVAXPCOM_JAR); + if (!jar.exists()) { + jar = new File(this.getClass().getProtectionDomain().getCodeSource().getLocation().getPath()); + if (!jar.exists()) + throw new XPCOMInitializationException("Could not find " + JAVAXPCOM_JAR + + " in " + aLibXULDirectory); + } + + URL[] urls = new URL[1]; + try { + urls[0] = jar.toURI().toURL(); + } catch (MalformedURLException e) { + throw new XPCOMInitializationException(e); + } + ClassLoader loader = new URLClassLoader(urls, + this.getClass().getClassLoader()); + + try { + Class mozillaClass = Class.forName("org.mozilla.xpcom.internal.MozillaImpl", + true, loader); + mozilla = (IMozilla) mozillaClass.newInstance(); + + Class greClass = Class.forName("org.mozilla.xpcom.internal.GREImpl", + true, loader); + gre = (IGRE) greClass.newInstance(); + + Class xpcomClass = Class.forName("org.mozilla.xpcom.internal.XPCOMImpl", + true, loader); + xpcom = (IXPCOM) xpcomClass.newInstance(); + + Class javaXPCOMClass = + Class.forName("org.mozilla.xpcom.internal.JavaXPCOMMethods", + true, loader); + jxutils = (IJavaXPCOMUtils) javaXPCOMClass.newInstance(); + } catch (Exception e) { + throw new XPCOMInitializationException("Could not load " + + "org.mozilla.xpcom.internal.* classes", e); + } + + mozilla.initialize(aLibXULDirectory); + } + + /** + * Initializes libXUL for embedding purposes. + * <p> + * NOTE: This function must be called from the "main" thread. + * <p> + * NOTE: At the present time, this function may only be called once in + * a given process. Use <code>termEmbedding</code> to clean up and free + * resources allocated by <code>initEmbedding</code>. + * + * @param aLibXULDirectory The directory in which the libXUL shared library + * was found. + * @param aAppDirectory The directory in which the application components + * and resources can be found. This will map to + * the "resource:app" directory service key. + * @param aAppDirProvider A directory provider for the application. This + * provider will be aggregated by a libXUL provider + * which will provide the base required GRE keys. + * + * @throws XPCOMException if a failure occurred during initialization + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public void initEmbedding(File aLibXULDirectory, File aAppDirectory, + IAppFileLocProvider aAppDirProvider) throws XPCOMException { + try { + gre.initEmbedding(aLibXULDirectory, aAppDirectory, aAppDirProvider); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Terminates libXUL embedding. + * <p> + * NOTE: Release any references to XPCOM objects that you may be holding + * before calling this function. + * + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public void termEmbedding() { + try { + gre.termEmbedding(); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } finally { + mozilla = null; + gre = null; + xpcom = null; + } + } + + /** + * Lock a profile directory using platform-specific semantics. + * + * @param aDirectory The profile directory to lock. + * + * @return A lock object. The directory will remain locked until the lock is + * released by invoking the <code>release</code> method, or by the + * termination of the JVM, whichever comes first. + * + * @throws XPCOMException if profile is already locked (with + * <code>errorcode</code> == <code>NS_ERROR_FILE_ACCESS_DENIED</code>); + * or if a failure occurred + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public ProfileLock lockProfileDirectory(File aDirectory) + throws XPCOMException { + try { + return gre.lockProfileDirectory(aDirectory); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Fire notifications to inform the toolkit about a new profile. This + * method should be called after <code>initEmbedding</code> if the + * embedder wishes to run with a profile. + * <p> + * Normally the embedder should call <code>lockProfileDirectory</code> + * to lock the directory before calling this method. + * <p> + * NOTE: There are two possibilities for selecting a profile: + * <ul> + * <li> + * Select the profile before calling <code>initEmbedding</code>. + * The aAppDirProvider object passed to <code>initEmbedding</code> + * should provide the NS_APP_USER_PROFILE_50_DIR key, and + * may also provide the following keys: + * <ul> + * <li>NS_APP_USER_PROFILE_LOCAL_50_DIR + * <li>NS_APP_PROFILE_DIR_STARTUP + * <li>NS_APP_PROFILE_LOCAL_DIR_STARTUP + * </ul> + * In this scenario <code>notifyProfile</code> should be called + * immediately after <code>initEmbedding</code>. Component + * registration information will be stored in the profile and + * JS components may be stored in the fastload cache. + * </li> + * <li> + * Select a profile some time after calling <code>initEmbedding</code>. + * In this case the embedder must install a directory service + * provider which provides NS_APP_USER_PROFILE_50_DIR and optionally + * NS_APP_USER_PROFILE_LOCAL_50_DIR. Component registration information + * will be stored in the application directory and JS components will not + * fastload. + * </li> + * </ul> + * + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public void notifyProfile() { + try { + gre.notifyProfile(); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Initializes XPCOM. You must call this method before proceeding + * to use XPCOM. + * + * @param aMozBinDirectory The directory containing the component + * registry and runtime libraries; + * or use <code>null</code> to use the working + * directory. + * + * @param aAppFileLocProvider The object to be used by Gecko that specifies + * to Gecko where to find profiles, the component + * registry preferences and so on; or use + * <code>null</code> for the default behaviour. + * + * @return the service manager + * + * @throws XPCOMException <ul> + * <li> NS_ERROR_NOT_INITIALIZED - if static globals were not initialied, + * which can happen if XPCOM is reloaded, but did not completly + * shutdown. </li> + * <li> Other error codes indicate a failure during initialisation. </li> + * </ul> + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public nsIServiceManager initXPCOM(File aMozBinDirectory, + IAppFileLocProvider aAppFileLocProvider) throws XPCOMException { + try { + return xpcom.initXPCOM(aMozBinDirectory, aAppFileLocProvider); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Shutdown XPCOM. You must call this method after you are finished + * using xpcom. + * + * @param aServMgr The service manager which was returned by initXPCOM. + * This will release servMgr. + * + * @throws XPCOMException if a failure occurred during termination + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public void shutdownXPCOM(nsIServiceManager aServMgr) throws XPCOMException { + try { + xpcom.shutdownXPCOM(aServMgr); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } finally { + mozilla = null; + gre = null; + xpcom = null; + } + } + + /** + * Public Method to access to the service manager. + * + * @return the service manager + * + * @throws XPCOMException if a failure occurred + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public nsIServiceManager getServiceManager() throws XPCOMException { + try { + return xpcom.getServiceManager(); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Public Method to access to the component manager. + * + * @return the component manager + * + * @throws XPCOMException if a failure occurred + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public nsIComponentManager getComponentManager() throws XPCOMException { + try { + return xpcom.getComponentManager(); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * Public Method to access to the component registration manager. + * + * @return the component registration manager + * + * @throws XPCOMException if a failure occurred + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public nsIComponentRegistrar getComponentRegistrar() throws XPCOMException { + try { + return xpcom.getComponentRegistrar(); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + // #ifdef VBOX + public int waitForEvents(long tmo) throws XPCOMException { + try { + return xpcom.waitForEvents(tmo); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + // #endif // VBOX + + /** + * Public Method to create an instance of a nsILocalFile. + * + * @param aPath A string which specifies a full file path to a + * location. Relative paths will be treated as an + * error (NS_ERROR_FILE_UNRECOGNIZED_PATH). + * @param aFollowLinks This attribute will determine if the nsLocalFile will + * auto resolve symbolic links. By default, this value + * will be false on all non unix systems. On unix, this + * attribute is effectively a noop. + * + * @return an instance of an nsILocalFile that points to given path + * + * @throws XPCOMException <ul> + * <li> NS_ERROR_FILE_UNRECOGNIZED_PATH - raised for unrecognized paths + * or relative paths (must supply full file path) </li> + * </ul> + * @throws XPCOMInitializationException if Mozilla was not properly + * initialized + */ + public nsILocalFile newLocalFile(String aPath, boolean aFollowLinks) + throws XPCOMException { + try { + return xpcom.newLocalFile(aPath, aFollowLinks); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + /** + * If you create a class that implements nsISupports, you will need to provide + * an implementation of the <code>queryInterface</code> method. This helper + * function provides a simple implementation. Therefore, if your class does + * not need to do anything special with <code>queryInterface</code>, your + * implementation would look like: + * <pre> + * public nsISupports queryInterface(String aIID) { + * return XPCOM.queryInterface(this, aIID); + * } + * </pre> + * + * @param aObject object to query + * @param aIID requested interface IID + * + * @return <code>aObject</code> if the given object supports that + * interface; + * <code>null</code> otherwise. + */ + public static nsISupports queryInterface(nsISupports aObject, String aIID) { + ArrayList<Class> classes = new ArrayList<Class>(); + classes.add(aObject.getClass()); + + while (!classes.isEmpty()) { + Class clazz = classes.remove(0); + + // Skip over any class/interface in the "java.*" and "javax.*" domains. + String className = clazz.getName(); + if (className.startsWith("java.") || className.startsWith("javax.")) { + continue; + } + + // If given IID matches that of the current interface, then we + // know that aObject implements the interface specified by the given IID. + if (clazz.isInterface() && className.startsWith("org.mozilla")) { + String iid = Mozilla.getInterfaceIID(clazz); + if (iid != null && aIID.equals(iid)) { + return aObject; + } + } + + // clazz didn't match, so add the interfaces it implements + Class[] interfaces = clazz.getInterfaces(); + for (int i = 0; i < interfaces.length; i++ ) { + classes.add(interfaces[i]); + } + + // Also add its superclass + Class superclass = clazz.getSuperclass(); + if (superclass != null) { + classes.add(superclass); + } + } + + return null; + } + + /** + * Gets the interface IID for a particular Java interface. This is similar + * to NS_GET_IID in the C++ Mozilla files. + * + * @param aInterface interface which has defined an IID + * + * @return IID for given interface + */ + public static String getInterfaceIID(Class aInterface) { + // Get short class name (i.e. "bar", not "org.blah.foo.bar") + StringBuffer iidName = new StringBuffer(); + String fullClassName = aInterface.getName(); + int index = fullClassName.lastIndexOf("."); + String className = index > 0 ? fullClassName.substring(index + 1) + : fullClassName; + + // Create iid field name + if (className.startsWith("ns")) { + iidName.append("NS_"); + iidName.append(className.substring(2).toUpperCase()); + } else { + iidName.append(className.toUpperCase()); + } + iidName.append("_IID"); + + String iid; + try { + Field iidField = aInterface.getDeclaredField(iidName.toString()); + iid = (String) iidField.get(null); + } catch (NoSuchFieldException e) { + // Class may implement non-Mozilla interfaces, which would not have an + // IID method. In that case, just null. + iid = null; + } catch (IllegalAccessException e) { + // Not allowed to access that field for some reason. Write out an + // error message, but don't fail. + System.err.println("ERROR: Could not get field " + iidName.toString()); + iid = null; + } + + return iid; + } + + public long getNativeHandleFromAWT(Object widget) { + try { + return mozilla.getNativeHandleFromAWT(widget); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + public long wrapJavaObject(Object aJavaObject, String aIID) { + try { + return jxutils.wrapJavaObject(aJavaObject, aIID); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + + public Object wrapXPCOMObject(long aXPCOMObject, String aIID) { + try { + return jxutils.wrapXPCOMObject(aXPCOMObject, aIID); + } catch (NullPointerException e) { + throw new XPCOMInitializationException("Must call " + + "Mozilla.getInstance().initialize() before using this method", e); + } + } + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/ProfileLock.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/ProfileLock.java new file mode 100644 index 00000000..f995a389 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/ProfileLock.java @@ -0,0 +1,63 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +public class ProfileLock { + + private long lock = 0; + + public ProfileLock(long aLockObject) { + lock = aLockObject; + } + + public void release() { + releaseNative(lock); + lock = 0; + } + + private native void releaseNative(long aLockObject); + + public boolean isValid() { + return lock != 0; + } + + protected void finalize() throws Throwable { + release(); + super.finalize(); + } + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/VersionComparator.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/VersionComparator.java new file mode 100644 index 00000000..f9fb1058 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/VersionComparator.java @@ -0,0 +1,272 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2005 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + +import java.util.Enumeration; +import java.util.StringTokenizer; + +import org.mozilla.interfaces.nsISupports; +/* import org.mozilla.interfaces.nsIVersionComparator; */ + + +/** + * Version strings are dot-separated sequences of version-parts. + * <p> + * A version-part consists of up to four parts, all of which are optional: + * <br><code> + * <number-a><string-b><number-c> + * <string-d (everything else)> + * </code> <p> + * A version-part may also consist of a single asterisk "*" which indicates + * "infinity". + * <p> + * Numbers are base-10, and are zero if left out. + * Strings are compared bytewise. + * <p> + * For additional backwards compatibility, if "string-b" is "+" then + * "number-a" is incremented by 1 and "string-b" becomes "pre". + * <p> <pre> + * 1.0pre1 + * < 1.0pre2 + * < 1.0 == 1.0.0 == 1.0.0.0 + * < 1.1pre == 1.1pre0 == 1.0+ + * < 1.1pre1a + * < 1.1pre1 + * < 1.1pre10a + * < 1.1pre10 + * </pre> + * Although not required by this interface, it is recommended that + * numbers remain within the limits of a signed char, i.e. -127 to 128. + */ +public class VersionComparator implements nsISupports /* implements nsIVersionComparator */ { + + public nsISupports queryInterface(String aIID) { + return Mozilla.queryInterface(this, aIID); + } + + /** + * Compare two version strings + * @param A a version string + * @param B a version string + * @return a value less than 0 if A < B; + * the value 0 if A == B; + * or a value greater than 0 if A > B + */ + public int compare(String A, String B) { + int result; + String a = A, b = B; + + do { + VersionPart va = new VersionPart(); + VersionPart vb = new VersionPart(); + a = parseVersionPart(a, va); + b = parseVersionPart(b, vb); + + result = compareVersionPart(va, vb); + if (result != 0) { + break; + } + } while (a != null || b != null); + + return result; + } + + private class VersionPart { + int numA = 0; + String strB; + int numC = 0; + String extraD; + } + + private static String parseVersionPart(String aVersion, VersionPart result) { + if (aVersion == null || aVersion.length() == 0) { + return aVersion; + } + + StringTokenizer tok = new StringTokenizer(aVersion.trim(), "."); + String part = tok.nextToken(); + + if (part.equals("*")) { + result.numA = Integer.MAX_VALUE; + result.strB = ""; + } else { + VersionPartTokenizer vertok = new VersionPartTokenizer(part); + try { + result.numA = Integer.parseInt(vertok.nextToken()); + } catch (NumberFormatException e) { + // parsing error; default to zero like 'strtol' C function + result.numA = 0; + } + + if (vertok.hasMoreElements()) { + String str = vertok.nextToken(); + + // if part is of type "<num>+" + if (str.charAt(0) == '+') { + result.numA++; + result.strB = "pre"; + } else { + // else if part is of type "<num><alpha>..." + result.strB = str; + + if (vertok.hasMoreTokens()) { + try { + result.numC = Integer.parseInt(vertok.nextToken()); + } catch (NumberFormatException e) { + // parsing error; default to zero like 'strtol' C function + result.numC = 0; + } + if (vertok.hasMoreTokens()) { + result.extraD = vertok.getRemainder(); + } + } + } + } + } + + if (tok.hasMoreTokens()) { + // return everything after "." + return aVersion.substring(part.length() + 1); + } + return null; + } + + private int compareVersionPart(VersionPart va, VersionPart vb) { + int res = compareInt(va.numA, vb.numA); + if (res != 0) { + return res; + } + + res = compareString(va.strB, vb.strB); + if (res != 0) { + return res; + } + + res = compareInt(va.numC, vb.numC); + if (res != 0) { + return res; + } + + return compareString(va.extraD, vb.extraD); + } + + private int compareInt(int n1, int n2) { + return n1 - n2; + } + + private int compareString(String str1, String str2) { + // any string is *before* no string + if (str1 == null) { + return (str2 != null) ? 1 : 0; + } + + if (str2 == null) { + return -1; + } + + return str1.compareTo(str2); + } + +} + +/** + * Specialized tokenizer for Mozilla version strings. A token can + * consist of one of the four sections of a version string: <code> + * <number-a><string-b><number-c> + * <string-d (everything else)></code>. + */ +class VersionPartTokenizer implements Enumeration { + + String part; + + public VersionPartTokenizer(String aPart) { + part = aPart; + } + + public boolean hasMoreElements() { + return part.length() != 0; + } + + public boolean hasMoreTokens() { + return part.length() != 0; + } + + public Object nextElement() { + if (part.matches("[\\+\\-]?[0-9].*")) { + // if string starts with a number... + int index = 0; + if (part.charAt(0) == '+' || part.charAt(0) == '-') { + index = 1; + } + + while (index < part.length() && Character.isDigit(part.charAt(index))) { + index++; + } + + String numPart = part.substring(0, index); + part = part.substring(index); + return numPart; + } else { + // ... or if this is the non-numeric part of version string + int index = 0; + while (index < part.length() && !Character.isDigit(part.charAt(index))) { + index++; + } + + String alphaPart = part.substring(0, index); + part = part.substring(index); + return alphaPart; + } + } + + public String nextToken() { + return (String) nextElement(); + } + + /** + * Returns what remains of the original string, without tokenization. This + * method is useful for getting the <code><string-d (everything else)> + * </code> section of a version string. + * + * @return remaining version string + */ + public String getRemainder() { + return part; + } + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMException.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMException.java new file mode 100644 index 00000000..9eca58f6 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMException.java @@ -0,0 +1,95 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2004 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + + +/** + * This exception is thrown whenever an internal XPCOM/Gecko error occurs. + * You can query the error ID returned by XPCOM by checking + * <code>errorcode</code> field. + */ +public class XPCOMException extends RuntimeException { + + /** + * The XPCOM error value. + */ + public long errorcode; + + private static final long serialVersionUID = 198521829884000593L; + + /** + * Constructs a new XPCOMException instance, with a default error + * (NS_ERROR_FAILURE) and message. + */ + public XPCOMException() { + this(0x80004005L, "Unspecified internal XPCOM error"); + } + + /** + * Constructs a new XPCOMException instance with the given message, passing + * NS_ERROR_FAILURE as the error code. + * + * @param message detailed message of exception + */ + public XPCOMException(String message) { + this(0x80004005L, message); + } + + /** + * Constructs a new XPCOMException instance with the given code, passing + * a default message. + * + * @param code internal XPCOM error ID + */ + public XPCOMException(long code) { + this(code, "Internal XPCOM error"); + } + + /** + * Constructs a new XPCOMException instance with an error code and message. + * + * @param code internal XPCOM error ID + * @param message detailed message of exception + */ + public XPCOMException(long code, String message) { + super(message + " (0x" + Long.toHexString(code) + ")"); + this.errorcode = code; + } + +} + diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMInitializationException.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMInitializationException.java new file mode 100644 index 00000000..26ce5325 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMInitializationException.java @@ -0,0 +1,56 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom; + + +public class XPCOMInitializationException extends RuntimeException { + + private static final long serialVersionUID = -7067350325909231055L; + + public XPCOMInitializationException(String message) { + super(message); + } + + public XPCOMInitializationException(Throwable cause) { + super(cause); + } + + public XPCOMInitializationException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/GREImpl.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/GREImpl.java new file mode 100644 index 00000000..74821c36 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/GREImpl.java @@ -0,0 +1,63 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + +import java.io.File; + +import org.mozilla.xpcom.IAppFileLocProvider; +import org.mozilla.xpcom.IGRE; +import org.mozilla.xpcom.ProfileLock; + + +public class GREImpl implements IGRE { + + public void initEmbedding(File aLibXULDirectory, File aAppDirectory, + IAppFileLocProvider aAppDirProvider) { + initEmbeddingNative(aLibXULDirectory, aAppDirectory, aAppDirProvider); + } + + public native void initEmbeddingNative(File aLibXULDirectory, + File aAppDirectory, IAppFileLocProvider aAppDirProvider); + + public native void termEmbedding(); + + public native ProfileLock lockProfileDirectory(File aDirectory); + + public native void notifyProfile(); + +} + diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/JavaXPCOMMethods.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/JavaXPCOMMethods.java new file mode 100644 index 00000000..ab0ca251 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/JavaXPCOMMethods.java @@ -0,0 +1,104 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + +import java.io.File; + +import org.mozilla.xpcom.IJavaXPCOMUtils; + + +public class JavaXPCOMMethods implements IJavaXPCOMUtils { + + public static void registerJavaXPCOMMethods(File aLibXULDirectory) { + // load JNI library + String path = ""; + if (aLibXULDirectory != null) { + path = aLibXULDirectory + File.separator; + } + + if (false) + { + String osName = System.getProperty("os.name").toLowerCase(); + if (osName.startsWith("os/2")) { + System.load(path + System.mapLibraryName("jxpcmglu")); + } else { + System.load(path + System.mapLibraryName("javaxpcomglue")); + } + } else { + // #ifdef VBOX + try { + System.load(path + System.mapLibraryName("vboxjxpcom")); + } catch (java.lang.UnsatisfiedLinkError ule) { + System.loadLibrary("vboxjxpcom"); + } + // #endif + } + registerJavaXPCOMMethodsNative(aLibXULDirectory); + } + + public static native void + registerJavaXPCOMMethodsNative(File aLibXULDirectory); + + /** + * Returns the Class object associated with the class or interface with the + * given string name, using the class loader of the given object. + * + * @param aObject the Java object whose class loader is used to load class + * @param aClassName the fully qualified name of desired class + * @return the Class object of requested Class; <code>null</code> if the + * class was not found + * + * @see http://java.sun.com/j2se/1.3/docs/guide/jni/jni-12.html#classops + */ + public static Class findClassInLoader(Object aObject, String aClassName) { + try { + if (aObject == null) { + return Class.forName(aClassName); + } else { + return Class.forName(aClassName, true, + aObject.getClass().getClassLoader()); + } + } catch (ClassNotFoundException e) { + return null; + } + } + + public native long wrapJavaObject(Object aJavaObject, String aIID); + + public native Object wrapXPCOMObject(long aXPCOMObject, String aIID); + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/MozillaImpl.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/MozillaImpl.java new file mode 100644 index 00000000..27fd9482 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/MozillaImpl.java @@ -0,0 +1,56 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + +import java.io.File; + +import org.mozilla.xpcom.IMozilla; +import org.mozilla.xpcom.XPCOMInitializationException; + +public class MozillaImpl implements IMozilla { + + public void initialize(File aLibXULDirectory) + throws XPCOMInitializationException { + JavaXPCOMMethods.registerJavaXPCOMMethods(aLibXULDirectory); + initializeNative(); + } + + private native void initializeNative(); + + public native long getNativeHandleFromAWT(Object widget); + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMImpl.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMImpl.java new file mode 100644 index 00000000..1111a9e0 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMImpl.java @@ -0,0 +1,73 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2006 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + +import java.io.File; + +import org.mozilla.xpcom.IAppFileLocProvider; +import org.mozilla.xpcom.IXPCOM; + +import org.mozilla.interfaces.nsIComponentManager; +import org.mozilla.interfaces.nsIComponentRegistrar; +import org.mozilla.interfaces.nsILocalFile; +import org.mozilla.interfaces.nsIServiceManager; + + +public class XPCOMImpl implements IXPCOM { + + public nsIServiceManager initXPCOM(File aMozBinDirectory, + IAppFileLocProvider aAppFileLocProvider) { + return initXPCOMNative(aMozBinDirectory, aAppFileLocProvider); + } + + public native nsIServiceManager initXPCOMNative(File aMozBinDirectory, + IAppFileLocProvider aAppFileLocProvider); + + public native void shutdownXPCOM(nsIServiceManager aServMgr); + + public native nsIComponentManager getComponentManager(); + + public native nsIComponentRegistrar getComponentRegistrar(); + + public native nsIServiceManager getServiceManager(); + + public native nsILocalFile newLocalFile(String aPath, boolean aFollowLinks); + + // #ifdef VBOX + public native int waitForEvents(long timeout); + // #endif VBOX +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxy.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxy.java new file mode 100644 index 00000000..c6485708 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxy.java @@ -0,0 +1,257 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2004 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; + +import org.mozilla.xpcom.XPCOMException; + + +/** + * This class is used to pass XPCOM objects to Java functions. A + * <code>java.lang.reflect.Proxy</code> instance is created using the expected + * interface, and all calls to the proxy are forwarded to the XPCOM object. + */ +public class XPCOMJavaProxy implements InvocationHandler { + + /** + * Pointer to the XPCOM object for which we are a proxy. + */ + protected long nativeXPCOMPtr; + + /** + * Default constructor. + * + * @param aXPCOMInstance address of XPCOM object as a long + */ + public XPCOMJavaProxy(long aXPCOMInstance) { + nativeXPCOMPtr = aXPCOMInstance; + } + + /** + * Returns the XPCOM object that the given proxy references. + * + * @param aProxy Proxy created by <code>createProxy</code> + * + * @return address of XPCOM object as a long + */ + protected static long getNativeXPCOMInstance(Object aProxy) { + XPCOMJavaProxy proxy = (XPCOMJavaProxy) Proxy.getInvocationHandler(aProxy); + return proxy.nativeXPCOMPtr; + } + + /** + * Creates a Proxy for the given XPCOM object. + * + * @param aInterface interface from which to create Proxy + * @param aXPCOMInstance address of XPCOM object as a long + * + * @return Proxy of given XPCOM object + */ + protected static Object createProxy(Class aInterface, long aXPCOMInstance) { + // XXX We should really get the class loader from |aInterface|. However, + // that class loader doesn't know about |XPCOMJavaProxyBase|. So for + // now, we get the class loader that loaded |XPCOMJavaProxy|. When + // we get rid of the "XPCOMJavaProxyBase.java" class, we can revert + // to the old method below. +// return Proxy.newProxyInstance(aInterface.getClassLoader(), + return Proxy.newProxyInstance(XPCOMJavaProxy.class.getClassLoader(), + new Class[] { aInterface, XPCOMJavaProxyBase.class }, + new XPCOMJavaProxy(aXPCOMInstance)); + } + + /** + * All calls to the Java proxy are forwarded to this method. This method + * takes care of a few of the <code>Object</code> method calls; all other + * calls are forwarded to the XPCOM object. + * + * @param aProxy Proxy created by <code>createProxy</code> + * @param aMethod object that describes the called method + * @param aParams array of the arguments passed to the method + * + * @return return value as defined by given <code>aMethod</code> + */ + public Object invoke(Object aProxy, Method aMethod, Object[] aParams) + throws Throwable { + String methodName = aMethod.getName(); + + // Handle the three java.lang.Object methods that are passed to us. + if (aMethod.getDeclaringClass() == Object.class) { + if (methodName.equals("hashCode")) { + return proxyHashCode(aProxy); + } + if (methodName.equals("equals")) { + return proxyEquals(aProxy, aParams[0]); + } + if (methodName.equals("toString")) { + return proxyToString(aProxy); + } + System.err.println("WARNING: Unhandled Object method [" + + methodName + "]"); + return null; + } + + // Handle the 'finalize' method called during garbage collection + if (aMethod.getDeclaringClass() == XPCOMJavaProxyBase.class) { + if (methodName.equals("finalize")) { + finalizeProxy(aProxy); + } else { + System.err.println("WARNING: Unhandled XPCOMJavaProxyBase method [" + + methodName + "]"); + } + return null; + } + + // If not already handled, pass method calls to XPCOM object. + return callXPCOMMethod(aProxy, methodName, aParams); + } + + /** + * Handles method calls of <code>java.lang.Object.hashCode</code> + * + * @param aProxy Proxy created by <code>createProxy</code> + * + * @return Integer object representing hash code of given object + * + * @see Object#hashCode() + */ + protected static Integer proxyHashCode(Object aProxy) { + return new Integer(System.identityHashCode(aProxy)); + } + + /** + * Handles method calls of <code>java.lang.Object.equals</code> + * + * @param aProxy Proxy created by <code>createProxy</code> + * @param aOther another object + * + * @return <code>true</code> if the given objects are the same; + * <code>false</code> otherwise + * + * @see Object#equals(Object) + */ + protected static Boolean proxyEquals(Object aProxy, Object aOther) { + // See if the two are the same Java object + if (aProxy == aOther) { + return Boolean.TRUE; + } else { + // If not, then see if they represent the same XPCOM object. But first, + // we need to check if |aOther| is an XPCOMJavaProxy. + if (isXPCOMJavaProxy(aOther) && isSameXPCOMObject(aProxy, aOther)) { + return Boolean.TRUE; + } + } + return Boolean.FALSE; + } + + /** + * Indicates whether the given object is an XPCOMJavaProxy. + * + * @param aObject object to check + * + * @return <code>true</code> if the given object is an XPCOMJavaProxy; + * <code>false</code> otherwise + */ + protected static boolean isXPCOMJavaProxy(Object aObject) { + if (aObject != null && Proxy.isProxyClass(aObject.getClass())) { + InvocationHandler h = Proxy.getInvocationHandler(aObject); + if (h instanceof XPCOMJavaProxy) { + return true; + } + } + return false; + } + + /** + * Checks if the two given XPCOMJavaProxy objects are proxies for + * the same XPCOM object. + * + * @param aProxy1 XPCOMJavaProxy created by <code>createProxy</code> + * @param aProxy2 XPCOMJavaProxy created by <code>createProxy</code> + * + * @return <code>true</code> if both proxies represent the same XPCOM object; + * <code>false</code> otherwise + */ + protected static native boolean isSameXPCOMObject(Object aProxy1, + Object aProxy2); + + /** + * Handles method calls of <code>java.lang.Object.toString</code> + * + * @param aProxy Proxy created by <code>createProxy</code> + * + * @return String representation of given object + * + * @see Object#toString() + */ + protected static String proxyToString(Object aProxy) { + return aProxy.getClass().getInterfaces()[0].getName() + '@' + + Integer.toHexString(aProxy.hashCode()); + } + + /** + * Called when the proxy is garbage collected by the JVM. Allows us to clean + * up any references to the XPCOM object. + * + * @param aProxy reference to Proxy that is being garbage collected + */ + protected void finalizeProxy(Object aProxy) throws Throwable { + finalizeProxyNative(aProxy); + super.finalize(); + } + + protected static native void finalizeProxyNative(Object aProxy); + + /** + * Calls the XPCOM object referenced by the proxy with the given method. + * + * @param aProxy Proxy created by <code>createProxy</code> + * @param aMethodName name of method that we want to call + * @param aParams array of params passed to method + * + * @return return value as defined by given method + * + * @exception XPCOMException if XPCOM method failed. Values of XPCOMException + * are defined by the method called. + */ + protected static native Object callXPCOMMethod(Object aProxy, + String aMethodName, Object[] aParams); + +} diff --git a/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxyBase.java b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxyBase.java new file mode 100644 index 00000000..595a7a2c --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxyBase.java @@ -0,0 +1,53 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Java XPCOM Bindings. + * + * The Initial Developer of the Original Code is + * IBM Corporation. + * Portions created by the Initial Developer are Copyright (C) 2004 + * IBM Corporation. All Rights Reserved. + * + * Contributor(s): + * Javier Pedemonte (jhpedemonte@gmail.com) + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +package org.mozilla.xpcom.internal; + + +/** + * This interface forms the foundation of any XPCOMJavaProxy that is created. + * It allows us to handle any JVM calls to <code>finalize</code> when the Proxy + * is garbage collected. + */ +public interface XPCOMJavaProxyBase { + + /** + * @see java.lang.Object#finalize() + */ + void finalize() throws Throwable; + +} diff --git a/src/libs/xpcom18a4/java/src/org/virtualbox/VBoxObjectBase.java b/src/libs/xpcom18a4/java/src/org/virtualbox/VBoxObjectBase.java new file mode 100644 index 00000000..29491595 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/org/virtualbox/VBoxObjectBase.java @@ -0,0 +1,31 @@ +/* $Id: VBoxObjectBase.java $ */ +/* + * Copyright (C) 2010-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program 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 for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * SPDX-License-Identifier: GPL-3.0-only + */ +import org.mozilla.interfaces.nsISupports; + +public abstract class VBoxObjectBase implements nsISupports +{ + public nsISupports queryInterface(String iid) + { + return org.mozilla.xpcom.Mozilla.queryInterface(this, iid); + } +} |