From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- src/libs/xpcom18a4/java/Makefile.kmk | 230 +++ src/libs/xpcom18a4/java/README.vbox | 5 + src/libs/xpcom18a4/java/src/MacJawt.mm | 47 + src/libs/xpcom18a4/java/src/dlldeps-javaxpcom.cpp | 81 + .../java/src/nsAppFileLocProviderProxy.cpp | 253 +++ .../xpcom18a4/java/src/nsAppFileLocProviderProxy.h | 65 + src/libs/xpcom18a4/java/src/nsFileStreams.cpp | 475 +++++ src/libs/xpcom18a4/java/src/nsFileStreams.h | 153 ++ src/libs/xpcom18a4/java/src/nsIFileStreams.h | 209 ++ src/libs/xpcom18a4/java/src/nsJavaInterfaces.cpp | 557 ++++++ src/libs/xpcom18a4/java/src/nsJavaInterfaces.h | 121 ++ src/libs/xpcom18a4/java/src/nsJavaWrapper.cpp | 2020 ++++++++++++++++++++ src/libs/xpcom18a4/java/src/nsJavaWrapper.h | 75 + .../xpcom18a4/java/src/nsJavaXPCOMBindingUtils.cpp | 1084 +++++++++++ .../xpcom18a4/java/src/nsJavaXPCOMBindingUtils.h | 392 ++++ src/libs/xpcom18a4/java/src/nsJavaXPCOMGlue.cpp | 535 ++++++ src/libs/xpcom18a4/java/src/nsJavaXPTCStub.cpp | 1711 +++++++++++++++++ src/libs/xpcom18a4/java/src/nsJavaXPTCStub.h | 153 ++ .../xpcom18a4/java/src/nsJavaXPTCStubWeakRef.cpp | 98 + .../xpcom18a4/java/src/nsJavaXPTCStubWeakRef.h | 63 + src/libs/xpcom18a4/java/src/nsThreadUtils.h | 399 ++++ src/libs/xpcom18a4/java/src/nsXPTCUtils.h | 128 ++ .../src/org/mozilla/xpcom/GREVersionRange.java | 80 + .../src/org/mozilla/xpcom/IAppFileLocProvider.java | 92 + .../xpcom18a4/java/src/org/mozilla/xpcom/IGRE.java | 127 ++ .../src/org/mozilla/xpcom/IJavaXPCOMUtils.java | 59 + .../java/src/org/mozilla/xpcom/IMozilla.java | 63 + .../java/src/org/mozilla/xpcom/INIParser.java | 243 +++ .../java/src/org/mozilla/xpcom/IXPCOM.java | 137 ++ .../java/src/org/mozilla/xpcom/Mozilla.java | 1079 +++++++++++ .../java/src/org/mozilla/xpcom/ProfileLock.java | 63 + .../src/org/mozilla/xpcom/VersionComparator.java | 272 +++ .../java/src/org/mozilla/xpcom/XPCOMException.java | 95 + .../xpcom/XPCOMInitializationException.java | 56 + .../src/org/mozilla/xpcom/internal/GREImpl.java | 63 + .../mozilla/xpcom/internal/JavaXPCOMMethods.java | 104 + .../org/mozilla/xpcom/internal/MozillaImpl.java | 56 + .../src/org/mozilla/xpcom/internal/XPCOMImpl.java | 73 + .../org/mozilla/xpcom/internal/XPCOMJavaProxy.java | 257 +++ .../mozilla/xpcom/internal/XPCOMJavaProxyBase.java | 53 + .../java/src/org/virtualbox/VBoxObjectBase.java | 31 + src/libs/xpcom18a4/java/tools/gen-nsError.pl | 161 ++ .../tools/genifaces/GenerateJavaInterfaces.cpp | 952 +++++++++ src/libs/xpcom18a4/java/tools/genjifaces.xsl | 600 ++++++ 44 files changed, 13570 insertions(+) create mode 100644 src/libs/xpcom18a4/java/Makefile.kmk create mode 100644 src/libs/xpcom18a4/java/README.vbox create mode 100644 src/libs/xpcom18a4/java/src/MacJawt.mm create mode 100644 src/libs/xpcom18a4/java/src/dlldeps-javaxpcom.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.h create mode 100644 src/libs/xpcom18a4/java/src/nsFileStreams.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsFileStreams.h create mode 100644 src/libs/xpcom18a4/java/src/nsIFileStreams.h create mode 100644 src/libs/xpcom18a4/java/src/nsJavaInterfaces.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaInterfaces.h create mode 100644 src/libs/xpcom18a4/java/src/nsJavaWrapper.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaWrapper.h create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.h create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPCOMGlue.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPTCStub.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPTCStub.h create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.cpp create mode 100644 src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.h create mode 100644 src/libs/xpcom18a4/java/src/nsThreadUtils.h create mode 100644 src/libs/xpcom18a4/java/src/nsXPTCUtils.h create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/GREVersionRange.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IAppFileLocProvider.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IGRE.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IJavaXPCOMUtils.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IMozilla.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/INIParser.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/IXPCOM.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/Mozilla.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/ProfileLock.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/VersionComparator.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMException.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/XPCOMInitializationException.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/GREImpl.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/JavaXPCOMMethods.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/MozillaImpl.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMImpl.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxy.java create mode 100644 src/libs/xpcom18a4/java/src/org/mozilla/xpcom/internal/XPCOMJavaProxyBase.java create mode 100644 src/libs/xpcom18a4/java/src/org/virtualbox/VBoxObjectBase.java create mode 100755 src/libs/xpcom18a4/java/tools/gen-nsError.pl create mode 100644 src/libs/xpcom18a4/java/tools/genifaces/GenerateJavaInterfaces.cpp create mode 100644 src/libs/xpcom18a4/java/tools/genjifaces.xsl (limited to 'src/libs/xpcom18a4/java') diff --git a/src/libs/xpcom18a4/java/Makefile.kmk b/src/libs/xpcom18a4/java/Makefile.kmk new file mode 100644 index 00000000..ed447fc5 --- /dev/null +++ b/src/libs/xpcom18a4/java/Makefile.kmk @@ -0,0 +1,230 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for Java bindings +# + +# +# 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 . +# +# SPDX-License-Identifier: GPL-3.0-only +# + +SUB_DEPTH = ../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# +# Globals +# +VBOX_JXPCOM_SRC := $(PATH_SUB_CURRENT) + +VBOX_JXPCOM_TARGET := $(PATH_TARGET)/vboxjxpcom-gen +VBOX_JXPCOM_JDEST := $(VBOX_JXPCOM_TARGET)/jdest + +VBOX_GLUE_XSLT_DIR := $(PATH_ROOT)/src/VBox/Main/glue + +ifndef VBOX_ONLY_SDK + # + # VBoxJXpcom - Java<->XPCOM native library + # + DLLS += VBoxJXpcom + + VBoxJXpcom_TEMPLATE = XPComDll + VBoxJXpcom_CXXFLAGS = -Wno-write-strings + VBoxJXpcom_DEFS = \ + EXPORT_XPTI_API \ + EXPORT_XPT_API \ + VBOX_WITH_XPCOM + VBoxJXpcom_NAME = libvboxjxpcom + VBoxJXpcom_DLLSUFF.darwin = .jnilib + VBoxJXpcom_INCS = \ + src \ + $(VBOX_JAVA_INC) \ + $(VBOX_PATH_XPCOM_SRC)/xpcom/glue \ + $(VBOX_PATH_XPCOM_SRC)/xpcom/build \ + $(VBOX_JXPCOM_JDEST) + VBoxJXpcom_SOURCES = \ + src/nsAppFileLocProviderProxy.cpp \ + src/nsJavaWrapper.cpp \ + src/nsJavaXPCOMBindingUtils.cpp \ + src/nsJavaXPTCStub.cpp \ + src/nsJavaXPTCStubWeakRef.cpp \ + src/nsJavaXPCOMGlue.cpp \ + src/nsJavaInterfaces.cpp + VBoxJXpcom_LIBS = \ + $(PATH_STAGE_LIB)/VBoxCOM$(VBOX_SUFF_LIB) \ + $(PATH_STAGE_BIN)/VBoxXPCOM$(VBOX_SUFF_DLL) + + #VBoxJXpcom_ORDERDEPS = $(VBOX_JXPCOM_GENH) + #VBoxJXpcom_CLEAN = $(VBOX_JXPCOM_GENH) + VBOX_JXPCOM_GENH = \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_internal_XPCOMImpl.h \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_internal_GREImpl.h \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_internal_MozillaImpl.h \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_internal_XPCOMJavaProxy.h \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_internal_JavaXPCOMMethods.h \ + $(VBOX_JXPCOM_JDEST)/org_mozilla_xpcom_ProfileLock.h + +endif # !VBOX_ONLY_SDK + +# +# Install JAR files +# +INSTALLS += VBoxJXpcom-inst-jar + +VBOX_JXPCOM_JAR = $(VBoxJXpcom-inst-jar_0_OUTDIR)/vboxjxpcom.jar +VBOX_JXPCOM_NSERROR = $(VBOX_JXPCOM_GEN)/java/XPCOMError.java +ifndef VBOX_WITH_JAVA_SUPPORT_IN_XPIDL + VBOX_JXPCOM_GEN = $(VBOX_JXPCOM_TARGET)/jxpcomgen +else + VBOX_JXPCOM_GEN = $(VBOX_JXPCOM_TARGET)/jxpcomgen-idl +endif + +VBoxJXpcom-inst-jar_INST = $(INST_SDK)bindings/xpcom/java/ +VBoxJXpcom-inst-jar_MODE = a+r,u+w +VBoxJXpcom-inst-jar_SOURCES = \ + $(VBOX_JXPCOM_JAR) +VBoxJXpcom-inst-jar_CLEAN = \ + $(VBOX_JXPCOM_JAR) \ + $(VBOX_JXPCOM_NSERROR) \ + $(VBOX_JXPCOM_GEN)/jxpcomgen.list \ + $(VBOX_JXPCOM_GEN)/jxpcomglue.list \ + $(wildcard \ + $(VBOX_JXPCOM_GEN)/java/*.java \ + $(VBOX_JXPCOM_GEN)/java/glue/*.java \ + $(VBOX_JXPCOM_JDEST)/*.class \ + $(VBOX_JXPCOM_JDEST)/*/*.class \ + $(VBOX_JXPCOM_JDEST)/*/*/*.class \ + $(VBOX_JXPCOM_JDEST)/*/*/*/*.class \ + $(VBOX_JXPCOM_JDEST)/*/*/*/*/*.class \ + $(VBOX_JXPCOM_JDEST)/*/*/*/*/*/*.class \ + ) +VBoxJXpcom-inst-jar_BLDDIRS += $(VBOX_JXPCOM_GEN)/java $(VBOX_JXPCOM_GEN)/java/glue $(VBOX_JXPCOM_GEN)/java/interfaces + +# +# For VBoxJXpcom, not currently used. +# +$(VBOX_JXPCOM_GENH): $$(VBOX_JXPCOM_JAR) + $(call MSG_L1,Generating $@ from $<) + $(QUIET)$(VBOX_JAVAH) -classpath $(VBOX_JXPCOM_JDEST) -d $(VBOX_JXPCOM_JDEST) \ + org.mozilla.xpcom.internal.XPCOMImpl \ + org.mozilla.xpcom.internal.GREImpl \ + org.mozilla.xpcom.internal.MozillaImpl \ + org.mozilla.xpcom.internal.XPCOMJavaProxy \ + org.mozilla.xpcom.ProfileLock \ + org.mozilla.xpcom.internal.JavaXPCOMMethods + +# +# Generate error constants. +# +$(VBOX_JXPCOM_NSERROR): $(VBOX_PATH_XPCOM_SRC)/xpcom/base/nsError.h $(VBOX_JXPCOM_SRC)/tools/gen-nsError.pl | $(VBOX_JXPCOM_GEN)/java/ + $(call MSG_L1,Generating $@) + $(QUIET)perl $(VBOX_JXPCOM_SRC)/tools/gen-nsError.pl < $< > $@ + +ifndef VBOX_WITH_JAVA_SUPPORT_IN_XPIDL + # + # Generate .java interface files from .xidl + # + + $(VBOX_JXPCOM_GEN)/jxpcomgen.list: \ + $(VBOX_XIDL_FILE) \ + $(VBOX_FILESPLIT) \ + $(VBOX_JXPCOM_SRC)/tools/genjifaces.xsl \ + | $(VBOX_JXPCOM_GEN)/java/interfaces/ + $(call MSG_L1,Generating Java interface files) + $(QUIET)$(RM) -f $(wildcard $(VBOX_JXPCOM_GEN)/java/interfaces/*.java) + $(QUIET)$(VBOX_XSLTPROC) \ + -o $(VBOX_JXPCOM_GEN)/java/interfaces/merged.file $(VBOX_JXPCOM_SRC)/tools/genjifaces.xsl $< + $(QUIET)$(VBOX_FILESPLIT) $(VBOX_JXPCOM_GEN)/java/interfaces/merged.file $(VBOX_JXPCOM_GEN)/java/interfaces + $(QUIET)echo $(VBOX_JXPCOM_GEN)/java/interfaces/*.java > $@ + +else # VBOX_WITH_JAVA_SUPPORT_IN_XPIDL + # + # Generate .java interface files from the XPCOM and VirtualBox IDL files. + # + # Note! There is not a 1:1 relationship between input and output files here, unfortunately. + # Note! VBOX_JXPCOM_NSERROR shares the output directory with us. + # + $(VBOX_JXPCOM_GEN)/jxpcomgen.list: \ + $(VBOX_PATH_SDK)/bindings/xpcom/idl/VirtualBox_XPCOM.idl \ + $$(addprefix $(VBOX_PATH_XPCOM_SRC)/,$$(XPCOM_IDLFILES)) \ + $(VBOX_XPIDL) \ + | $(VBOX_JXPCOM_GEN)/java/ + $(call MSG_L1,Generating XPCOM Java interface files from IDL) + $(QUIET)$(RM) -f $(filter-out %/XPCOMError.java, $(wildcard $(VBOX_JXPCOM_GEN)/java/*.java)) + $(foreach idl, $(VBOX_PATH_SDK)/bindings/xpcom/idl/VirtualBox_XPCOM.idl $(addprefix $(VBOX_PATH_XPCOM_SRC)/,$(XPCOM_IDLFILES))\ + , $(NLTAB)$(QUIET)$(VBOX_XPIDL) -m java $(XPIDL_INCS) -e $(VBOX_JXPCOM_GEN)/java/$(basename $(notdir $(idl))).java $(idl) ) + $(QUIET)echo $(VBOX_JXPCOM_GEN)/java/*.java > $@ +endif # VBOX_WITH_JAVA_SUPPORT_IN_XPIDL + +$(VBOX_JXPCOM_GEN)/jxpcomglue.list: \ + $(VBOX_XIDL_FILE) \ + $(VBOX_GLUE_XSLT_DIR)/glue-java.xsl \ + $(VBOX_FILESPLIT) \ + | $(VBOX_JXPCOM_GEN)/java/glue/ + $(call MSG_L1,Generating Java glue files from XIDL) + $(QUIET)$(RM) -f $(wildcard $(VBOX_JXPCOM_GEN)/java/glue/*.java) + $(QUIET)$(VBOX_XSLTPROC) \ + --stringparam filelistonly "" \ + --stringparam G_vboxApiSuffix $(VBOX_API_SUFFIX) \ + --stringparam G_vboxGlueStyle xpcom \ + --stringparam G_vboxDirPrefix "" \ + -o $(VBOX_JXPCOM_GEN)/java/glue/merged.file $(VBOX_GLUE_XSLT_DIR)/glue-java.xsl $< + $(QUIET)$(VBOX_FILESPLIT) $(VBOX_JXPCOM_GEN)/java/glue/merged.file $(VBOX_JXPCOM_GEN)/java/glue/ + $(QUIET)echo $(VBOX_JXPCOM_GEN)/java/glue/*.java > $@ + +# +# Compile the all java code into a JAR file. +# +VBOX_JXPCOM_JSRC = $(VBOX_JXPCOM_SRC)/src/org/mozilla/xpcom +VBOX_JXPCOM_JAR_SRC = \ + $(VBOX_JXPCOM_JSRC)/IXPCOM.java \ + $(VBOX_JXPCOM_JSRC)/Mozilla.java \ + $(VBOX_JXPCOM_JSRC)/VersionComparator.java \ + $(VBOX_JXPCOM_JSRC)/GREVersionRange.java \ + $(VBOX_JXPCOM_JSRC)/IAppFileLocProvider.java \ + $(VBOX_JXPCOM_JSRC)/ProfileLock.java \ + $(VBOX_JXPCOM_JSRC)/IGRE.java \ + $(VBOX_JXPCOM_JSRC)/IJavaXPCOMUtils.java \ + $(VBOX_JXPCOM_JSRC)/XPCOMException.java \ + $(VBOX_JXPCOM_JSRC)/IMozilla.java \ + $(VBOX_JXPCOM_JSRC)/XPCOMInitializationException.java \ + $(VBOX_JXPCOM_JSRC)/INIParser.java \ + $(VBOX_JXPCOM_JSRC)/internal/GREImpl.java \ + $(VBOX_JXPCOM_JSRC)/internal/JavaXPCOMMethods.java \ + $(VBOX_JXPCOM_JSRC)/internal/MozillaImpl.java \ + $(VBOX_JXPCOM_JSRC)/internal/XPCOMImpl.java \ + $(VBOX_JXPCOM_JSRC)/internal/XPCOMJavaProxyBase.java \ + $(VBOX_JXPCOM_JSRC)/internal/XPCOMJavaProxy.java + +$$(VBOX_JXPCOM_JAR): $(VBOX_JXPCOM_JAR_SRC) $(VBOX_JXPCOM_GEN)/jxpcomgen.list $(VBOX_JXPCOM_GEN)/jxpcomglue.list $(VBOX_JXPCOM_NSERROR) $(VBOX_JXPCOM_MGR) | $$(dir $$@) + $(call MSG_TOOL,javac,$(notdir $@),jxpcomgen.list,) + $(QUIET)$(RM) -Rf $(VBOX_JXPCOM_JDEST) + $(QUIET)$(MKDIR) -p $(VBOX_JXPCOM_JDEST) + $(QUIET)$(VBOX_JAVAC) $(VBOX_JAVAC_OPTS) @$(VBOX_JXPCOM_GEN)/jxpcomgen.list \ + -d $(VBOX_JXPCOM_JDEST) -classpath $(VBOX_JXPCOM_JDEST) + $(call MSG_TOOL,javac,$(notdir $@),...,) + $(QUIET)$(VBOX_JAVAC) $(VBOX_JAVAC_OPTS) \ + $(VBOX_JXPCOM_JAR_SRC) \ + $(VBOX_JXPCOM_NSERROR) \ + @$(VBOX_JXPCOM_GEN)/jxpcomglue.list \ + -d $(VBOX_JXPCOM_JDEST) -classpath $(VBOX_JXPCOM_JDEST) + $(call MSG_LINK,$(notdir $@),$@) + $(QUIET)$(VBOX_JAR) cf $@ -C $(VBOX_JXPCOM_JDEST) . + +include $(FILE_KBUILD_SUB_FOOTER) diff --git a/src/libs/xpcom18a4/java/README.vbox b/src/libs/xpcom18a4/java/README.vbox new file mode 100644 index 00000000..b22acc4d --- /dev/null +++ b/src/libs/xpcom18a4/java/README.vbox @@ -0,0 +1,5 @@ + JavaXPCOM sources (see https://developer.mozilla.org/en/JavaXPCOM) were taken from +:pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot, directory extensions/java/xpcom, +Apr 29 2010. + + Imported to VirtualBox codebase in revision . diff --git a/src/libs/xpcom18a4/java/src/MacJawt.mm b/src/libs/xpcom18a4/java/src/MacJawt.mm new file mode 100644 index 00000000..a2d0d3f8 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/MacJawt.mm @@ -0,0 +1,47 @@ +/* ***** 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 ***** */ + +#include +#import +#include "prtypes.h" + + +PRUint64 GetPlatformHandle(JAWT_DrawingSurfaceInfo* dsi) +{ + JAWT_MacOSXDrawingSurfaceInfo* dsi_mac = + static_cast (dsi->platformInfo); + return reinterpret_cast (dsi_mac->cocoaViewRef); +} diff --git a/src/libs/xpcom18a4/java/src/dlldeps-javaxpcom.cpp b/src/libs/xpcom18a4/java/src/dlldeps-javaxpcom.cpp new file mode 100644 index 00000000..a78d6c1d --- /dev/null +++ b/src/libs/xpcom18a4/java/src/dlldeps-javaxpcom.cpp @@ -0,0 +1,81 @@ +/* ***** 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 ***** */ + +#include "nsJavaInterfaces.h" + + +void XXXNeverCalled_javaxpcom() +{ + MOZILLA_NATIVE(initialize) (nsnull, nsnull); + + GRE_NATIVE(initEmbedding) (nsnull, nsnull, nsnull, nsnull, nsnull); + + GRE_NATIVE(termEmbedding) (nsnull, nsnull); + + GRE_NATIVE(lockProfileDirectory) (nsnull, nsnull, nsnull); + + GRE_NATIVE(notifyProfile) (nsnull, nsnull); + + GRE_NATIVE(lockProfileDirectory) (nsnull, nsnull, nsnull); + + GRE_NATIVE(notifyProfile) (nsnull, nsnull); + + XPCOM_NATIVE(initXPCOM) (nsnull, nsnull, nsnull, nsnull); + + XPCOM_NATIVE(shutdownXPCOM) (nsnull, nsnull, nsnull); + + XPCOM_NATIVE(newLocalFile) (nsnull, nsnull, nsnull, nsnull); + + XPCOM_NATIVE(getComponentManager) (nsnull, nsnull); + + XPCOM_NATIVE(getComponentRegistrar) (nsnull, nsnull); + + XPCOM_NATIVE(getServiceManager) (nsnull, nsnull); + + JAVAPROXY_NATIVE(callXPCOMMethod) (nsnull, nsnull, nsnull, nsnull, nsnull); + + JAVAPROXY_NATIVE(finalizeProxy) (nsnull, nsnull, nsnull); + + JAVAPROXY_NATIVE(isSameXPCOMObject) (nsnull, nsnull, nsnull, nsnull); + + LOCKPROXY_NATIVE(release) (nsnull, nsnull, nsnull); + + MOZILLA_NATIVE(getNativeHandleFromAWT) (nsnull, nsnull, nsnull); + + JXUTILS_NATIVE(wrapJavaObject) (nsnull, nsnull, nsnull, nsnull); + + JXUTILS_NATIVE(wrapXPCOMObject) (nsnull, nsnull, nsnull, nsnull); +} diff --git a/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.cpp b/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.cpp new file mode 100644 index 00000000..c10bf4c1 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.cpp @@ -0,0 +1,253 @@ +/* ***** 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 ***** */ + +#include "nsAppFileLocProviderProxy.h" +#include "nsJavaXPCOMBindingUtils.h" +#include "nsILocalFile.h" +#include "nsISimpleEnumerator.h" + + +nsAppFileLocProviderProxy::nsAppFileLocProviderProxy(jobject aJavaObject) +{ + mJavaLocProvider = GetJNIEnv()->NewGlobalRef(aJavaObject); +} + +nsAppFileLocProviderProxy::~nsAppFileLocProviderProxy() +{ + GetJNIEnv()->DeleteGlobalRef(mJavaLocProvider); +} + +NS_IMPL_ISUPPORTS2(nsAppFileLocProviderProxy, + nsIDirectoryServiceProvider, + nsIDirectoryServiceProvider2) + + +// nsIDirectoryServiceProvider + +NS_IMETHODIMP +nsAppFileLocProviderProxy::GetFile(const char* aProp, PRBool* aIsPersistant, + nsIFile** aResult) +{ + // Setup params for calling Java function + JNIEnv* env = GetJNIEnv(); + jstring prop = env->NewStringUTF(aProp); + if (!prop) + return NS_ERROR_OUT_OF_MEMORY; + jbooleanArray persistant = env->NewBooleanArray(1); + if (!persistant) + return NS_ERROR_OUT_OF_MEMORY; + + // Create method ID + jmethodID mid = nsnull; + jclass clazz = env->GetObjectClass(mJavaLocProvider); + if (clazz) { + mid = env->GetMethodID(clazz, "getFile", + "(Ljava/lang/String;[Z)Ljava/io/File;"); + } + if (!mid) + return NS_ERROR_FAILURE; + + // Call Java function + jobject javaFile = nsnull; + javaFile = env->CallObjectMethod(mJavaLocProvider, mid, prop, persistant); + if (javaFile == nsnull || env->ExceptionCheck()) + return NS_ERROR_FAILURE; + + // Set boolean output value + env->GetBooleanArrayRegion(persistant, 0, 1, (jboolean*) aIsPersistant); + + // Set nsIFile result value + nsCOMPtr localFile; + nsresult rv = File_to_nsILocalFile(env, javaFile, getter_AddRefs(localFile)); + if (NS_SUCCEEDED(rv)) { + return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)aResult); + } + + return rv; +} + + +// nsIDirectoryServiceProvider2 + +class DirectoryEnumerator : public nsISimpleEnumerator +{ +public: + NS_DECL_ISUPPORTS + + DirectoryEnumerator(jobjectArray aJavaFileArray) + : mIndex(0) + { + JNIEnv* env = GetJNIEnv(); + mJavaFileArray = static_cast + (env->NewGlobalRef(aJavaFileArray)); + mArraySize = env->GetArrayLength(aJavaFileArray); + } + + ~DirectoryEnumerator() + { + GetJNIEnv()->DeleteGlobalRef(mJavaFileArray); + } + + NS_IMETHOD HasMoreElements(PRBool* aResult) + { + if (!mJavaFileArray) { + *aResult = PR_FALSE; + } else { + *aResult = (mIndex < mArraySize); + } + return NS_OK; + } + + NS_IMETHOD GetNext(nsISupports** aResult) + { + nsresult rv = NS_ERROR_FAILURE; + + JNIEnv* env = GetJNIEnv(); + jobject javaFile = env->GetObjectArrayElement(mJavaFileArray, mIndex++); + if (javaFile) { + nsCOMPtr localFile; + rv = File_to_nsILocalFile(env, javaFile, getter_AddRefs(localFile)); + env->DeleteLocalRef(javaFile); + + if (NS_SUCCEEDED(rv)) { + return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)aResult); + } + } + + env->ExceptionClear(); + return NS_ERROR_FAILURE; + } + +private: + jobjectArray mJavaFileArray; + PRUint32 mArraySize; + PRUint32 mIndex; +}; + +NS_IMPL_ISUPPORTS1(DirectoryEnumerator, nsISimpleEnumerator) + +NS_IMETHODIMP +nsAppFileLocProviderProxy::GetFiles(const char* aProp, + nsISimpleEnumerator** aResult) +{ + nsresult rv = NS_OK; + + // Setup params for calling Java function + JNIEnv* env = GetJNIEnv(); + jstring prop = env->NewStringUTF(aProp); + if (!prop) + rv = NS_ERROR_OUT_OF_MEMORY; + + // Create method ID + jmethodID mid = nsnull; + if (NS_SUCCEEDED(rv)) { + jclass clazz = env->GetObjectClass(mJavaLocProvider); + if (clazz) { + mid = env->GetMethodID(clazz, "getFiles", + "(Ljava/lang/String;)[Ljava/io/File;"); + env->DeleteLocalRef(clazz); + } + if (!mid) + rv = NS_ERROR_FAILURE; + } + + // Call Java function + jobject javaFileArray = nsnull; + if (NS_SUCCEEDED(rv)) { + javaFileArray = env->CallObjectMethod(mJavaLocProvider, mid, prop); + + // Handle any exception thrown by Java method. + jthrowable exp = env->ExceptionOccurred(); + if (exp) { +#ifdef DEBUG + env->ExceptionDescribe(); +#endif + + // If the exception is an instance of XPCOMException, then get the + // nsresult from the exception instance. Else, default to + // NS_ERROR_FAILURE. + if (env->IsInstanceOf(exp, xpcomExceptionClass)) { + jfieldID fid; + fid = env->GetFieldID(xpcomExceptionClass, "errorcode", "J"); + if (fid) { + rv = env->GetLongField(exp, fid); + } else { + rv = NS_ERROR_FAILURE; + } + NS_ASSERTION(fid, "Couldn't get 'errorcode' field of XPCOMException"); + } else { + rv = NS_ERROR_FAILURE; + } + } else { + // No exception thrown. Check the result. + if (javaFileArray == nsnull) { + rv = NS_ERROR_FAILURE; + } + } + } + + if (NS_SUCCEEDED(rv)) { + // Parse return value + *aResult = new DirectoryEnumerator(static_cast + (javaFileArray)); + NS_ADDREF(*aResult); + return NS_OK; + } + + // Handle error conditions + *aResult = nsnull; + env->ExceptionClear(); + return rv; +} + + +//////////////////////////////////////////////////////////////////////////////// + +nsresult +NS_NewAppFileLocProviderProxy(jobject aJavaLocProvider, + nsIDirectoryServiceProvider** aResult) +{ + nsAppFileLocProviderProxy* provider = + new nsAppFileLocProviderProxy(aJavaLocProvider); + if (provider == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(provider); + + *aResult = provider; + return NS_OK; +} + diff --git a/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.h b/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.h new file mode 100644 index 00000000..d3b90880 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsAppFileLocProviderProxy.h @@ -0,0 +1,65 @@ +/* ***** 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 ***** */ + +#ifndef _nsAppFileLocProviderProxy_h_ +#define _nsAppFileLocProviderProxy_h_ + +#include "nsIDirectoryService.h" +#include "jni.h" + + +class nsAppFileLocProviderProxy : public nsIDirectoryServiceProvider2 +{ +public: + nsAppFileLocProviderProxy(jobject aJavaLocProvider); + ~nsAppFileLocProviderProxy(); + + NS_DECL_ISUPPORTS + NS_DECL_NSIDIRECTORYSERVICEPROVIDER + NS_DECL_NSIDIRECTORYSERVICEPROVIDER2 + +private: + jobject mJavaLocProvider; +}; + +extern "C" nsresult +NS_NewAppFileLocProviderProxy(jobject aJavaLocProvider, + nsIDirectoryServiceProvider** aResult); + + +#endif //_nsAppFileLocProviderProxy_h_ + diff --git a/src/libs/xpcom18a4/java/src/nsFileStreams.cpp b/src/libs/xpcom18a4/java/src/nsFileStreams.cpp new file mode 100644 index 00000000..435df58b --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsFileStreams.cpp @@ -0,0 +1,475 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * 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 ***** */ + +#if defined(XP_UNIX) || defined(XP_BEOS) +#include +#elif defined(XP_MAC) +#include +#elif defined(XP_WIN) +#include +#elif defined(XP_OS2) +#define INCL_DOSERRORS +#include +#else +// XXX add necessary include file for ftruncate (or equivalent) +#endif + +#if defined(XP_MAC) +#include "pprio.h" +#else +#include "private/pprio.h" +#endif + +#include "nsFileStreams.h" +#include "nsILocalFile.h" +#include "nsXPIDLString.h" +#include "prerror.h" +#include "nsCRT.h" +#include "nsInt64.h" +#include "nsIFile.h" + +#define NS_NO_INPUT_BUFFERING 1 // see http://bugzilla.mozilla.org/show_bug.cgi?id=41067 + +#if defined(PR_LOGGING) +// +// Log module for nsFileTransport logging... +// +// To enable logging (see prlog.h for full details): +// +// set NSPR_LOG_MODULES=nsFileIO:5 +// set NSPR_LOG_FILE=nspr.log +// +// this enables PR_LOG_DEBUG level information and places all output in +// the file nspr.log +// +PRLogModuleInfo* gFileIOLog = nsnull; + +#endif /* PR_LOGGING */ + + +//////////////////////////////////////////////////////////////////////////////// +// nsFileStream + +nsFileStream::nsFileStream() + : mFD(nsnull) + , mCloseFD(PR_TRUE) +{ +} + +nsFileStream::~nsFileStream() +{ + if (mCloseFD) + Close(); +} + +NS_IMPL_THREADSAFE_ISUPPORTS1(nsFileStream, nsISeekableStream) + +nsresult +nsFileStream::InitWithFileDescriptor(PRFileDesc* fd, nsISupports* parent) +{ + NS_ENSURE_TRUE(mFD == nsnull, NS_ERROR_ALREADY_INITIALIZED); + // + // this file stream is dependent on its parent to keep the + // file descriptor valid. an owning reference to the parent + // prevents the file descriptor from going away prematurely. + // + mFD = fd; + mCloseFD = PR_FALSE; + mParent = parent; + return NS_OK; +} + +nsresult +nsFileStream::Close() +{ + nsresult rv = NS_OK; + if (mFD) { + if (mCloseFD) + if (PR_Close(mFD) == PR_FAILURE) + rv = NS_BASE_STREAM_OSERROR; + mFD = nsnull; + } + return rv; +} + +NS_IMETHODIMP +nsFileStream::Seek(PRInt32 whence, PRInt64 offset) +{ + if (mFD == nsnull) + return NS_BASE_STREAM_CLOSED; + + nsInt64 cnt = PR_Seek64(mFD, offset, (PRSeekWhence)whence); + if (cnt == nsInt64(-1)) { + return NS_ErrorAccordingToNSPR(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsFileStream::Tell(PRInt64 *result) +{ + if (mFD == nsnull) + return NS_BASE_STREAM_CLOSED; + + nsInt64 cnt = PR_Seek64(mFD, 0, PR_SEEK_CUR); + if (cnt == nsInt64(-1)) { + return NS_ErrorAccordingToNSPR(); + } + *result = cnt; + return NS_OK; +} + +NS_IMETHODIMP +nsFileStream::SetEOF() +{ + if (mFD == nsnull) + return NS_BASE_STREAM_CLOSED; + +#if defined(XP_UNIX) || defined(XP_MAC) || defined(XP_OS2) || defined(XP_BEOS) + // Some system calls require an EOF offset. + PRInt64 offset; + nsresult rv = Tell(&offset); + if (NS_FAILED(rv)) return rv; +#endif + +#if defined(XP_UNIX) || defined(XP_BEOS) + if (ftruncate(PR_FileDesc2NativeHandle(mFD), offset) != 0) { + NS_ERROR("ftruncate failed"); + return NS_ERROR_FAILURE; + } +#elif defined(XP_MAC) + if (::SetEOF(PR_FileDesc2NativeHandle(mFD), offset) != 0) { + NS_ERROR("SetEOF failed"); + return NS_ERROR_FAILURE; + } +#elif defined(XP_WIN) + if (!SetEndOfFile((HANDLE) PR_FileDesc2NativeHandle(mFD))) { + NS_ERROR("SetEndOfFile failed"); + return NS_ERROR_FAILURE; + } +#elif defined(XP_OS2) + if (DosSetFileSize((HFILE) PR_FileDesc2NativeHandle(mFD), offset) != NO_ERROR) { + NS_ERROR("DosSetFileSize failed"); + return NS_ERROR_FAILURE; + } +#else + // XXX not implemented +#endif + + return NS_OK; +} + +//////////////////////////////////////////////////////////////////////////////// +// nsFileInputStream + +NS_IMPL_ISUPPORTS_INHERITED3(nsFileInputStream, + nsFileStream, + nsIInputStream, + nsIFileInputStream, + nsILineInputStream) + +NS_METHOD +nsFileInputStream::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult) +{ + NS_ENSURE_NO_AGGREGATION(aOuter); + + nsFileInputStream* stream = new nsFileInputStream(); + if (stream == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(stream); + nsresult rv = stream->QueryInterface(aIID, aResult); + NS_RELEASE(stream); + return rv; +} + +nsresult +nsFileInputStream::Open(nsIFile* aFile, PRInt32 aIOFlags, PRInt32 aPerm) +{ + nsresult rv = NS_OK; + + // If the previous file is open, close it + if (mFD) { + rv = Close(); + if (NS_FAILED(rv)) return rv; + } + + // Open the file + nsCOMPtr localFile = do_QueryInterface(aFile, &rv); + if (NS_FAILED(rv)) return rv; + if (aIOFlags == -1) + aIOFlags = PR_RDONLY; + if (aPerm == -1) + aPerm = 0; + + PRFileDesc* fd; + rv = localFile->OpenNSPRFileDesc(aIOFlags, aPerm, &fd); + if (NS_FAILED(rv)) return rv; + + mFD = fd; + + if (mBehaviorFlags & DELETE_ON_CLOSE) { + // POSIX compatible filesystems allow a file to be unlinked while a + // file descriptor is still referencing the file. since we've already + // opened the file descriptor, we'll try to remove the file. if that + // fails, then we'll just remember the nsIFile and remove it after we + // close the file descriptor. + rv = aFile->Remove(PR_FALSE); + if (NS_FAILED(rv) && !(mBehaviorFlags & REOPEN_ON_REWIND)) { + // If REOPEN_ON_REWIND is not happenin', we haven't saved the file yet + mFile = aFile; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::Init(nsIFile* aFile, PRInt32 aIOFlags, PRInt32 aPerm, + PRInt32 aBehaviorFlags) +{ + NS_ENSURE_TRUE(!mFD, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(!mParent, NS_ERROR_ALREADY_INITIALIZED); + + mBehaviorFlags = aBehaviorFlags; + + // If the file will be reopened on rewind, save the info to open the file + if (mBehaviorFlags & REOPEN_ON_REWIND) { + mFile = aFile; + mIOFlags = aIOFlags; + mPerm = aPerm; + } + + return Open(aFile, aIOFlags, aPerm); +} + +NS_IMETHODIMP +nsFileInputStream::Close() +{ + nsresult rv = nsFileStream::Close(); + if (NS_FAILED(rv)) return rv; + if (mFile && (mBehaviorFlags & DELETE_ON_CLOSE)) { + rv = mFile->Remove(PR_FALSE); + NS_ASSERTION(NS_SUCCEEDED(rv), "failed to delete file"); + // If we don't need to save the file for reopening, free it up + if (!(mBehaviorFlags & REOPEN_ON_REWIND)) { + mFile = nsnull; + } + } + return rv; +} + +NS_IMETHODIMP +nsFileInputStream::Available(PRUint32* aResult) +{ + if (!mFD) { + return NS_BASE_STREAM_CLOSED; + } + + PRInt32 avail = PR_Available(mFD); + if (avail == -1) { + return NS_ErrorAccordingToNSPR(); + } + *aResult = avail; + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::Read(char* aBuf, PRUint32 aCount, PRUint32* aResult) +{ + if (!mFD) { + return NS_BASE_STREAM_CLOSED; + } + + PRInt32 bytesRead = PR_Read(mFD, aBuf, aCount); + if (bytesRead == -1) { + return NS_ErrorAccordingToNSPR(); + } + // Check if we're at the end of file and need to close + if (mBehaviorFlags & CLOSE_ON_EOF) { + if (bytesRead == 0) { + Close(); + } + } + + *aResult = bytesRead; + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::ReadLine(nsACString& aLine, PRBool* aResult) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsFileInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + PRUint32 aCount, PRUint32* aResult) +{ + // ReadSegments is not implemented because it would be inefficient when + // the writer does not consume all data. If you want to call ReadSegments, + // wrap a BufferedInputStream around the file stream. That will call + // Read(). + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsFileInputStream::IsNonBlocking(PRBool *aNonBlocking) +{ + *aNonBlocking = PR_FALSE; + return NS_OK; +} + +NS_IMETHODIMP +nsFileInputStream::Seek(PRInt32 aWhence, PRInt64 aOffset) +{ + if (!mFD) { + if (mBehaviorFlags & REOPEN_ON_REWIND) { + nsresult rv = Reopen(); + if (NS_FAILED(rv)) { + return rv; + } + } else { + return NS_BASE_STREAM_CLOSED; + } + } + + return nsFileStream::Seek(aWhence, aOffset); +} + +//////////////////////////////////////////////////////////////////////////////// +// nsFileOutputStream + +NS_IMPL_ISUPPORTS_INHERITED2(nsFileOutputStream, + nsFileStream, + nsIOutputStream, + nsIFileOutputStream) + +NS_METHOD +nsFileOutputStream::Create(nsISupports *aOuter, REFNSIID aIID, void **aResult) +{ + NS_ENSURE_NO_AGGREGATION(aOuter); + + nsFileOutputStream* stream = new nsFileOutputStream(); + if (stream == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(stream); + nsresult rv = stream->QueryInterface(aIID, aResult); + NS_RELEASE(stream); + return rv; +} + +NS_IMETHODIMP +nsFileOutputStream::Init(nsIFile* file, PRInt32 ioFlags, PRInt32 perm, + PRInt32 behaviorFlags) +{ + NS_ENSURE_TRUE(mFD == nsnull, NS_ERROR_ALREADY_INITIALIZED); + + nsresult rv; + nsCOMPtr localFile = do_QueryInterface(file, &rv); + if (NS_FAILED(rv)) return rv; + if (ioFlags == -1) + ioFlags = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE; + if (perm <= 0) + perm = 0664; + + PRFileDesc* fd; + rv = localFile->OpenNSPRFileDesc(ioFlags, perm, &fd); + if (NS_FAILED(rv)) return rv; + + mFD = fd; + return NS_OK; +} + +NS_IMETHODIMP +nsFileOutputStream::Close() +{ + return nsFileStream::Close(); +} + +NS_IMETHODIMP +nsFileOutputStream::Write(const char *buf, PRUint32 count, PRUint32 *result) +{ + if (mFD == nsnull) + return NS_BASE_STREAM_CLOSED; + + PRInt32 cnt = PR_Write(mFD, buf, count); + if (cnt == -1) { + return NS_ErrorAccordingToNSPR(); + } + *result = cnt; + return NS_OK; +} + +NS_IMETHODIMP +nsFileOutputStream::Flush(void) +{ + if (mFD == nsnull) + return NS_BASE_STREAM_CLOSED; + + PRInt32 cnt = PR_Sync(mFD); + if (cnt == -1) { + return NS_ErrorAccordingToNSPR(); + } + return NS_OK; +} + +NS_IMETHODIMP +nsFileOutputStream::WriteFrom(nsIInputStream *inStr, PRUint32 count, PRUint32 *_retval) +{ + NS_NOTREACHED("WriteFrom (see source comment)"); + return NS_ERROR_NOT_IMPLEMENTED; + // File streams intentionally do not support this method. + // If you need something like this, then you should wrap + // the file stream using nsIBufferedOutputStream +} + +NS_IMETHODIMP +nsFileOutputStream::WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval) +{ + NS_NOTREACHED("WriteSegments (see source comment)"); + return NS_ERROR_NOT_IMPLEMENTED; + // File streams intentionally do not support this method. + // If you need something like this, then you should wrap + // the file stream using nsIBufferedOutputStream +} + +NS_IMETHODIMP +nsFileOutputStream::IsNonBlocking(PRBool *aNonBlocking) +{ + *aNonBlocking = PR_FALSE; + return NS_OK; +} diff --git a/src/libs/xpcom18a4/java/src/nsFileStreams.h b/src/libs/xpcom18a4/java/src/nsFileStreams.h new file mode 100644 index 00000000..7d713fc5 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsFileStreams.h @@ -0,0 +1,153 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* ***** 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 mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * + * 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 ***** */ + +#ifndef nsFileStreams_h__ +#define nsFileStreams_h__ + +#include "nsIFileStreams.h" +#include "nsIFile.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsISeekableStream.h" +#include "nsILineInputStream.h" +#include "nsCOMPtr.h" +#include "prlog.h" +#include "prio.h" + +template class nsLineBuffer; + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileStream : public nsISeekableStream +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISEEKABLESTREAM + + nsFileStream(); + virtual ~nsFileStream(); + + nsresult Close(); + nsresult InitWithFileDescriptor(PRFileDesc* fd, nsISupports* parent); + +protected: + PRFileDesc* mFD; + nsCOMPtr mParent; // strong reference to parent nsFileIO, + // which ensures mFD remains valid. + PRBool mCloseFD; +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileInputStream : public nsFileStream, + public nsIFileInputStream, + public nsILineInputStream +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSIFILEINPUTSTREAM + NS_DECL_NSILINEINPUTSTREAM + + // Overrided from nsFileStream + NS_IMETHOD Seek(PRInt32 aWhence, PRInt64 aOffset); + + nsFileInputStream() : nsFileStream() + { + mBehaviorFlags = 0; + } + virtual ~nsFileInputStream() + { + Close(); + } + + static NS_METHOD + Create(nsISupports *aOuter, REFNSIID aIID, void **aResult); + +protected: + /** + * The file being opened. Only stored when DELETE_ON_CLOSE or + * REOPEN_ON_REWIND are true. + */ + nsCOMPtr mFile; + /** + * The IO flags passed to Init() for the file open. + * Only set for REOPEN_ON_REWIND. + */ + PRInt32 mIOFlags; + /** + * The permissions passed to Init() for the file open. + * Only set for REOPEN_ON_REWIND. + */ + PRInt32 mPerm; + /** + * Flags describing our behavior. See the IDL file for possible values. + */ + PRInt32 mBehaviorFlags; + +protected: + /** + * Internal, called to open a file. Parameters are the same as their + * Init() analogues. + */ + nsresult Open(nsIFile* file, PRInt32 ioFlags, PRInt32 perm); + /** + * Reopen the file (for OPEN_ON_READ only!) + */ + nsresult Reopen() { return Open(mFile, mIOFlags, mPerm); } +}; + +//////////////////////////////////////////////////////////////////////////////// + +class nsFileOutputStream : public nsFileStream, + public nsIFileOutputStream +{ +public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_NSIOUTPUTSTREAM + NS_DECL_NSIFILEOUTPUTSTREAM + + nsFileOutputStream() : nsFileStream() {} + virtual ~nsFileOutputStream() { nsFileOutputStream::Close(); } + + static NS_METHOD + Create(nsISupports *aOuter, REFNSIID aIID, void **aResult); +}; + +//////////////////////////////////////////////////////////////////////////////// + +#endif // nsFileStreams_h__ diff --git a/src/libs/xpcom18a4/java/src/nsIFileStreams.h b/src/libs/xpcom18a4/java/src/nsIFileStreams.h new file mode 100644 index 00000000..3df02b55 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsIFileStreams.h @@ -0,0 +1,209 @@ +/* + * DO NOT EDIT. THIS FILE IS GENERATED FROM nsIFileStreams.idl + */ + +#ifndef __gen_nsIFileStreams_h__ +#define __gen_nsIFileStreams_h__ + + +#ifndef __gen_nsIInputStream_h__ +#include "nsIInputStream.h" +#endif + +#ifndef __gen_nsIOutputStream_h__ +#include "nsIOutputStream.h" +#endif + +/* For IDL files that don't want to include root IDL files. */ +#ifndef NS_NO_VTABLE +#define NS_NO_VTABLE +#endif +class nsIFile; /* forward declaration */ + + +/* starting interface: nsIFileInputStream */ +#define NS_IFILEINPUTSTREAM_IID_STR "e3d56a20-c7ec-11d3-8cda-0060b0fc14a3" + +#define NS_IFILEINPUTSTREAM_IID \ + {0xe3d56a20, 0xc7ec, 0x11d3, \ + { 0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }} + +/** + * An input stream that allows you to read from a file. + */ +class NS_NO_VTABLE nsIFileInputStream : public nsIInputStream { + public: + + NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFILEINPUTSTREAM_IID) + + /** + * @param file file to read from (must QI to nsILocalFile) + * @param ioFlags file open flags listed in prio.h + * @param perm file mode bits listed in prio.h + * @param behaviorFlags flags specifying various behaviors of the class + * (see enumerations in the class) + */ + /* void init (in nsIFile file, in long ioFlags, in long perm, in long behaviorFlags); */ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) = 0; + + /** + * If this is set, the file will be deleted by the time the stream is + * closed. It may be removed before the stream is closed if it is possible + * to delete it and still read from it. + * + * If OPEN_ON_READ is defined, and the file was recreated after the first + * delete, the file will be deleted again when it is closed again. + */ + enum { DELETE_ON_CLOSE = 2 }; + + /** + * If this is set, the file will close automatically when the end of the + * file is reached. + */ + enum { CLOSE_ON_EOF = 4 }; + + /** + * If this is set, the file will be reopened whenever Seek(0) occurs. If + * the file is already open and the seek occurs, it will happen naturally. + * (The file will only be reopened if it is closed for some reason.) + */ + enum { REOPEN_ON_REWIND = 8 }; + +}; + +/* Use this macro when declaring classes that implement this interface. */ +#define NS_DECL_NSIFILEINPUTSTREAM \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags); \ + +/* Use this macro to declare functions that forward the behavior of this interface to another object. */ +#define NS_FORWARD_NSIFILEINPUTSTREAM(_to) \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) { return _to Init(file, ioFlags, perm, behaviorFlags); } \ + +/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */ +#define NS_FORWARD_SAFE_NSIFILEINPUTSTREAM(_to) \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(file, ioFlags, perm, behaviorFlags); } \ + +#if 0 +/* Use the code below as a template for the implementation class for this interface. */ + +/* Header file */ +class nsFileInputStream : public nsIFileInputStream +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIFILEINPUTSTREAM + + nsFileInputStream(); + +private: + ~nsFileInputStream(); + +protected: + /* additional members */ +}; + +/* Implementation file */ +NS_IMPL_ISUPPORTS1(nsFileInputStream, nsIFileInputStream) + +nsFileInputStream::nsFileInputStream() +{ + /* member initializers and constructor code */ +} + +nsFileInputStream::~nsFileInputStream() +{ + /* destructor code */ +} + +/* void init (in nsIFile file, in long ioFlags, in long perm, in long behaviorFlags); */ +NS_IMETHODIMP nsFileInputStream::Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* End of implementation class template. */ +#endif + + +/* starting interface: nsIFileOutputStream */ +#define NS_IFILEOUTPUTSTREAM_IID_STR "e6f68040-c7ec-11d3-8cda-0060b0fc14a3" + +#define NS_IFILEOUTPUTSTREAM_IID \ + {0xe6f68040, 0xc7ec, 0x11d3, \ + { 0x8c, 0xda, 0x00, 0x60, 0xb0, 0xfc, 0x14, 0xa3 }} + +/** + * An output stream that lets you stream to a file. + */ +class NS_NO_VTABLE nsIFileOutputStream : public nsIOutputStream { + public: + + NS_DEFINE_STATIC_IID_ACCESSOR(NS_IFILEOUTPUTSTREAM_IID) + + /** + * @param file - file to write to (must QI to nsILocalFile) + * @param ioFlags - file open flags listed in prio.h + * @param perm - file mode bits listed in prio.h + * @param behaviorFlags flags specifying various behaviors of the class + * (currently none supported) + */ + /* void init (in nsIFile file, in long ioFlags, in long perm, in long behaviorFlags); */ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) = 0; + +}; + +/* Use this macro when declaring classes that implement this interface. */ +#define NS_DECL_NSIFILEOUTPUTSTREAM \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags); + +/* Use this macro to declare functions that forward the behavior of this interface to another object. */ +#define NS_FORWARD_NSIFILEOUTPUTSTREAM(_to) \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) { return _to Init(file, ioFlags, perm, behaviorFlags); } + +/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */ +#define NS_FORWARD_SAFE_NSIFILEOUTPUTSTREAM(_to) \ + NS_IMETHOD Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) { return !_to ? NS_ERROR_NULL_POINTER : _to->Init(file, ioFlags, perm, behaviorFlags); } + +#if 0 +/* Use the code below as a template for the implementation class for this interface. */ + +/* Header file */ +class nsFileOutputStream : public nsIFileOutputStream +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIFILEOUTPUTSTREAM + + nsFileOutputStream(); + +private: + ~nsFileOutputStream(); + +protected: + /* additional members */ +}; + +/* Implementation file */ +NS_IMPL_ISUPPORTS1(nsFileOutputStream, nsIFileOutputStream) + +nsFileOutputStream::nsFileOutputStream() +{ + /* member initializers and constructor code */ +} + +nsFileOutputStream::~nsFileOutputStream() +{ + /* destructor code */ +} + +/* void init (in nsIFile file, in long ioFlags, in long perm, in long behaviorFlags); */ +NS_IMETHODIMP nsFileOutputStream::Init(nsIFile *file, PRInt32 ioFlags, PRInt32 perm, PRInt32 behaviorFlags) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + +/* End of implementation class template. */ +#endif + + +#endif /* __gen_nsIFileStreams_h__ */ diff --git a/src/libs/xpcom18a4/java/src/nsJavaInterfaces.cpp b/src/libs/xpcom18a4/java/src/nsJavaInterfaces.cpp new file mode 100644 index 00000000..103f2f37 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaInterfaces.cpp @@ -0,0 +1,557 @@ +/* ***** 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 ***** */ + +#include "nsJavaInterfaces.h" +#include "nsJavaWrapper.h" +#include "nsJavaXPCOMBindingUtils.h" +#include "nsJavaXPTCStub.h" +#include "nsIComponentRegistrar.h" +#include "nsString.h" +#include "nsISimpleEnumerator.h" +#include "nsIInterfaceInfoManager.h" +#include "nsIInputStream.h" +#include "nsEnumeratorUtils.h" +#include "nsAppFileLocProviderProxy.h" +#ifndef VBOX +#include "nsXULAppAPI.h" +#endif +#include "nsILocalFile.h" + +#ifdef XP_MACOSX +#include "jawt.h" +#endif + + +#ifdef VBOX +#if 0 +#include "org_mozilla_xpcom_internal_GREImpl.h" +#include "org_mozilla_xpcom_internal_JavaXPCOMMethods.h" +#include "org_mozilla_xpcom_internal_MozillaImpl.h" +#include "org_mozilla_xpcom_internal_XPCOMImpl.h" +#include "org_mozilla_xpcom_internal_XPCOMJavaProxy.h" +#include "org_mozilla_xpcom_ProfileLock.h" +#endif +#include +using namespace com; +#include +#include +#include +#endif + +extern "C" NS_EXPORT void JNICALL +MOZILLA_NATIVE(initialize) (JNIEnv* env, jobject) +{ + if (!InitializeJavaGlobals(env)) { + jclass clazz = + env->FindClass("org/mozilla/xpcom/XPCOMInitializationException"); + if (clazz) { + env->ThrowNew(clazz, "Failed to initialize JavaXPCOM"); + } + } +} + +nsresult +InitEmbedding_Impl(JNIEnv* env, jobject aLibXULDirectory, + jobject aAppDirectory, jobject aAppDirProvider) +{ + nsresult rv; + + // create an nsILocalFile from given java.io.File + nsCOMPtr libXULDir; + if (aLibXULDirectory) { + rv = File_to_nsILocalFile(env, aLibXULDirectory, getter_AddRefs(libXULDir)); + NS_ENSURE_SUCCESS(rv, rv); + } + nsCOMPtr appDir; + if (aAppDirectory) { + rv = File_to_nsILocalFile(env, aAppDirectory, getter_AddRefs(appDir)); + NS_ENSURE_SUCCESS(rv, rv); + } + + // create nsAppFileLocProviderProxy from given Java object + nsCOMPtr provider; + if (aAppDirProvider) { + rv = NS_NewAppFileLocProviderProxy(aAppDirProvider, + getter_AddRefs(provider)); + NS_ENSURE_SUCCESS(rv, rv); + } + + // init libXUL +#ifdef VBOX + return 0; +#else + return XRE_InitEmbedding(libXULDir, appDir, provider, nsnull, 0); +#endif +} + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(initEmbedding) (JNIEnv* env, jobject, jobject aLibXULDirectory, + jobject aAppDirectory, jobject aAppDirProvider) +{ + nsresult rv = InitEmbedding_Impl(env, aLibXULDirectory, aAppDirectory, + aAppDirProvider); + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "Failure in initEmbedding"); + FreeJavaGlobals(env); + } +} + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(termEmbedding) (JNIEnv *env, jobject) +{ + // Free globals before calling XRE_TermEmbedding(), since we need some + // XPCOM services. + FreeJavaGlobals(env); + +#ifndef VBOX + XRE_TermEmbedding(); +#endif +} +#ifdef VBOX +nsresult +InitXPCOMVBox_Impl(JNIEnv* env, jobject aVBoxBinDirectory) +{ +#if defined(VBOX_PATH_APP_PRIVATE_ARCH) && defined(VBOX_PATH_SHARED_LIBS) + rv = RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE); +#else + const char *pszHome = nsnull; + const char *jhome = nsnull; + jstring path = nsnull; + + int rv; + jclass clazz; + jmethodID getPathMID; + + if (aVBoxBinDirectory && + (clazz = env->FindClass("java/io/File")) && + (getPathMID = env->GetMethodID(clazz, "getAbsolutePath", + "()Ljava/lang/String;")) + ) + { + path = (jstring)env->CallObjectMethod(aVBoxBinDirectory, getPathMID); + pszHome = jhome = env->GetStringUTFChars(path, nsnull); + } + + if (pszHome == nsnull) + pszHome = getenv("VBOX_PROGRAM_PATH"); + + if (pszHome) { + size_t cchHome = strlen(pszHome); + char *pszExePath = (char *)alloca(cchHome + 32); + memcpy(pszExePath, pszHome, cchHome); + memcpy(pszExePath + cchHome, "/javafake", sizeof("/javafake")); + rv = RTR3InitEx(RTR3INIT_VER_CUR, RTR3INIT_FLAGS_DLL | RTR3INIT_FLAGS_UNOBTRUSIVE, 0, NULL, pszExePath); + } else { + rv = RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE); + } + + if (jhome) + env->ReleaseStringUTFChars(path, jhome); +#endif + + return com::Initialize(); +} +#endif + +nsresult +InitXPCOM_Impl(JNIEnv* env, jobject aMozBinDirectory, + jobject aAppFileLocProvider, jobject* aResult) +{ + nsresult rv; + // create an nsILocalFile from given java.io.File + nsCOMPtr directory; + if (aMozBinDirectory) { + rv = File_to_nsILocalFile(env, aMozBinDirectory, getter_AddRefs(directory)); + NS_ENSURE_SUCCESS(rv, rv); + } + + // create nsAppFileLocProviderProxy from given Java object + nsCOMPtr provider; + if (aAppFileLocProvider) { + rv = NS_NewAppFileLocProviderProxy(aAppFileLocProvider, + getter_AddRefs(provider)); + NS_ENSURE_SUCCESS(rv, rv); + } + + // init XPCOM + nsCOMPtr servMan; + rv = NS_InitXPCOM2(getter_AddRefs(servMan), directory, provider); + NS_ENSURE_SUCCESS(rv, rv); + + // create Java proxy for service manager returned by NS_InitXPCOM2 + return NativeInterfaceToJavaObject(env, servMan, NS_GET_IID(nsIServiceManager), + nsnull, aResult); +} + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(initXPCOM) (JNIEnv* env, jobject, jobject aMozBinDirectory, + jobject aAppFileLocProvider) +{ +#ifdef VBOX + nsresult rv = InitXPCOMVBox_Impl(env, aMozBinDirectory); + if (NS_SUCCEEDED(rv)) + return nsnull; +#else + jobject servMan; + nsresult rv = InitXPCOM_Impl(env, aMozBinDirectory, aAppFileLocProvider, + &servMan); + if (NS_SUCCEEDED(rv)) + return servMan; +#endif + + ThrowException(env, rv, "Failure in initXPCOM"); + FreeJavaGlobals(env); + return nsnull; +} + +extern "C" NS_EXPORT void JNICALL +#ifdef VBOX +XPCOM_NATIVE2(shutdownXPCOM) (JNIEnv *env, jobject, jobject aServMgr) +#else +XPCOM_NATIVE(shutdownXPCOM) (JNIEnv *env, jobject, jobject aServMgr) +#endif +{ +#ifdef VBOX + // Free globals before calling NS_ShutdownXPCOM(), since we need some + // XPCOM services. + //FreeJavaGlobals(env); + //com::Shutdown(); +#else + nsresult rv; + nsIServiceManager* servMgr = nsnull; + if (aServMgr) { + // Get native XPCOM instance + nsISupports* instancePtr = nsnull; + rv = JavaObjectToNativeInterface(env, aServMgr, + NS_GET_IID(nsIServiceManager), (void**) &instancePtr); + NS_ASSERTION(NS_SUCCEEDED(rv) && instancePtr != nsnull, + "Failed to get XPCOM obj for ServiceMgr."); + if (NS_SUCCEEDED(rv)) { + rv = instancePtr->QueryInterface(NS_GET_IID(nsIServiceManager), + (void**) &servMgr); + NS_ASSERTION(NS_SUCCEEDED(rv), "QI for nsIServiceManager failed"); + } + + // Even if we failed to get the matching xpcom object, we don't abort this + // function. Just call NS_ShutdownXPCOM with a null service manager. + } + + // Free globals before calling NS_ShutdownXPCOM(), since we need some + // XPCOM services. + FreeJavaGlobals(env); + + rv = NS_ShutdownXPCOM(servMgr); + if (NS_FAILED(rv)) + ThrowException(env, rv, "NS_ShutdownXPCOM failed"); +#endif +} + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(newLocalFile) (JNIEnv *env, jobject, jstring aPath, + jboolean aFollowLinks) +{ + // Create a Mozilla string from the jstring + const PRUnichar* buf = nsnull; + if (aPath) { + buf = env->GetStringChars(aPath, nsnull); + if (!buf) + return nsnull; // exception already thrown + } + + nsAutoString path_str(buf); + env->ReleaseStringChars(aPath, buf); + + // Make call to given function + nsCOMPtr file; + nsresult rv = NS_NewLocalFile(path_str, aFollowLinks, getter_AddRefs(file)); + + if (NS_SUCCEEDED(rv)) { + jobject javaProxy; + rv = NativeInterfaceToJavaObject(env, file, NS_GET_IID(nsILocalFile), + nsnull, &javaProxy); + if (NS_SUCCEEDED(rv)) + return javaProxy; + } + + ThrowException(env, rv, "Failure in newLocalFile"); + return nsnull; +} + +extern "C" NS_EXPORT jobject JNICALL +#ifdef VBOX +XPCOM_NATIVE2(getComponentManager) (JNIEnv *env, jobject) +#else +XPCOM_NATIVE(getComponentManager) (JNIEnv *env, jobject) +#endif +{ + // Call XPCOM method + nsCOMPtr cm; + nsresult rv = NS_GetComponentManager(getter_AddRefs(cm)); + + if (NS_SUCCEEDED(rv)) { + jobject javaProxy; + rv = NativeInterfaceToJavaObject(env, cm, NS_GET_IID(nsIComponentManager), + nsnull, &javaProxy); + if (NS_SUCCEEDED(rv)) + return javaProxy; + } + + ThrowException(env, rv, "Failure in getComponentManager"); + return nsnull; +} + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(getComponentRegistrar) (JNIEnv *env, jobject) +{ + // Call XPCOM method + nsCOMPtr cr; + nsresult rv = NS_GetComponentRegistrar(getter_AddRefs(cr)); + + if (NS_SUCCEEDED(rv)) { + jobject javaProxy; + rv = NativeInterfaceToJavaObject(env, cr, NS_GET_IID(nsIComponentRegistrar), + nsnull, &javaProxy); + if (NS_SUCCEEDED(rv)) + return javaProxy; + } + + ThrowException(env, rv, "Failure in getComponentRegistrar"); + return nsnull; +} + +#ifdef VBOX +# include +# include + +extern "C" NS_EXPORT jint JNICALL +XPCOM_NATIVE2(waitForEvents) (JNIEnv *env, jobject, jlong aTimeout) +{ + com::NativeEventQueue* aEventQ = com::NativeEventQueue::getMainEventQueue(); + NS_WARN_IF_FALSE(aEventQ != nsnull, "Null main event queue"); + if (!aEventQ) + return -1; + + int rc = aEventQ->processEventQueue(aTimeout < 0 ? RT_INDEFINITE_WAIT : (uint32_t)aTimeout); + + if (RT_SUCCESS(rc)) + return 0; + + if ( rc == VERR_TIMEOUT + || rc == VERR_INTERRUPTED) + return 1; + + return 2; +} +#endif + +extern "C" NS_EXPORT jobject JNICALL +#ifdef VBOX +XPCOM_NATIVE2(getServiceManager) (JNIEnv *env, jobject) +#else +XPCOM_NATIVE(getServiceManager) (JNIEnv *env, jobject) +#endif +{ + // Call XPCOM method + nsCOMPtr sm; + nsresult rv = NS_GetServiceManager(getter_AddRefs(sm)); + + if (NS_SUCCEEDED(rv)) { + jobject javaProxy; + rv = NativeInterfaceToJavaObject(env, sm, NS_GET_IID(nsIServiceManager), + nsnull, &javaProxy); + if (NS_SUCCEEDED(rv)) + return javaProxy; + } + + ThrowException(env, rv, "Failure in getServiceManager"); + return nsnull; +} + +extern "C" NS_EXPORT jobject JNICALL +GRE_NATIVE(lockProfileDirectory) (JNIEnv* env, jobject, jobject aDirectory) +{ + nsresult rv = NS_ERROR_FAILURE; + + if (aDirectory) { + nsCOMPtr profileDir; + rv = File_to_nsILocalFile(env, aDirectory, getter_AddRefs(profileDir)); + + if (NS_SUCCEEDED(rv)) { + nsISupports* lock; +#ifdef VBOX + rv = 0; + lock = 0; +#else + rv = XRE_LockProfileDirectory(profileDir, &lock); +#endif + + if (NS_SUCCEEDED(rv)) { + jclass clazz = + env->FindClass("org/mozilla/xpcom/ProfileLock"); + if (clazz) { + jmethodID mid = env->GetMethodID(clazz, "", "(J)V"); + if (mid) { + return env->NewObject(clazz, mid, reinterpret_cast(lock)); + } + } + + // if we get here, then something failed + rv = NS_ERROR_FAILURE; + } + } + } + + ThrowException(env, rv, "Failure in lockProfileDirectory"); + return nsnull; +} + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(notifyProfile) (JNIEnv *env, jobject) +{ +#ifndef VBOX + XRE_NotifyProfile(); +#endif +} + +#ifdef XP_MACOSX +extern PRUint64 GetPlatformHandle(JAWT_DrawingSurfaceInfo* dsi); +#endif + +extern "C" NS_EXPORT jlong JNICALL +MOZILLA_NATIVE(getNativeHandleFromAWT) (JNIEnv* env, jobject clazz, + jobject widget) +{ + PRUint64 handle = 0; + +#if defined(XP_MACOSX) && !defined(VBOX) + JAWT awt; + awt.version = JAWT_VERSION_1_4; + jboolean result = JAWT_GetAWT(env, &awt); + if (result == JNI_FALSE) + return 0; + + JAWT_DrawingSurface* ds = awt.GetDrawingSurface(env, widget); + if (ds != nsnull) { + jint lock = ds->Lock(ds); + if (!(lock & JAWT_LOCK_ERROR)) { + JAWT_DrawingSurfaceInfo* dsi = ds->GetDrawingSurfaceInfo(ds); + if (dsi) { + handle = GetPlatformHandle(dsi); + ds->FreeDrawingSurfaceInfo(dsi); + } + + ds->Unlock(ds); + } + + awt.FreeDrawingSurface(ds); + } +#else + NS_WARNING("getNativeHandleFromAWT JNI method not implemented"); +#endif + + return handle; +} + +extern "C" NS_EXPORT jlong JNICALL +JXUTILS_NATIVE(wrapJavaObject) (JNIEnv* env, jobject, jobject aJavaObject, + jstring aIID) +{ + nsresult rv; + void* xpcomObject = nsnull; + + if (!aJavaObject || !aIID) { + rv = NS_ERROR_NULL_POINTER; + } else { + const char* str = env->GetStringUTFChars(aIID, nsnull); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + } else { + nsID iid; + if (iid.Parse(str)) { + rv = JavaObjectToNativeInterface(env, aJavaObject, iid, &xpcomObject); + if (NS_SUCCEEDED(rv)) { + nsISupports *xpcom_nat_obj = (nsISupports*) xpcomObject; + rv = xpcom_nat_obj->QueryInterface(iid, &xpcomObject); + NS_IF_RELEASE(xpcom_nat_obj); + } + } else { + rv = NS_ERROR_INVALID_ARG; + } + + env->ReleaseStringUTFChars(aIID, str); + } + } + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "Failed to create XPCOM proxy for Java object"); + } + return reinterpret_cast(xpcomObject); +} + +extern "C" NS_EXPORT jobject JNICALL +JXUTILS_NATIVE(wrapXPCOMObject) (JNIEnv* env, jobject, jlong aXPCOMObject, + jstring aIID) +{ + nsresult rv; + jobject javaObject = nsnull; + nsISupports* xpcomObject = reinterpret_cast(aXPCOMObject); + + if (!xpcomObject || !aIID) { + rv = NS_ERROR_NULL_POINTER; + } else { + const char* str = env->GetStringUTFChars(aIID, nsnull); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + } else { + nsID iid; + if (iid.Parse(str)) { + // XXX Should we be passing something other than NULL for aObjectLoader? + rv = NativeInterfaceToJavaObject(env, xpcomObject, iid, nsnull, + &javaObject); + } else { + rv = NS_ERROR_INVALID_ARG; + } + + env->ReleaseStringUTFChars(aIID, str); + } + } + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "Failed to create XPCOM proxy for Java object"); + } + return javaObject; +} diff --git a/src/libs/xpcom18a4/java/src/nsJavaInterfaces.h b/src/libs/xpcom18a4/java/src/nsJavaInterfaces.h new file mode 100644 index 00000000..69d2f680 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaInterfaces.h @@ -0,0 +1,121 @@ +/* ***** 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 ***** */ + +#ifndef _nsJavaInterfaces_h_ +#define _nsJavaInterfaces_h_ + +#include "jni.h" +#include "nscore.h" + +#ifdef VBOX +#define MOZILLA_NATIVE(func) Java_org_mozilla_xpcom_internal_MozillaImpl_##func##Native +#define GRE_NATIVE(func) Java_org_mozilla_xpcom_internal_GREImpl_##func##Native +#define XPCOM_NATIVE(func) Java_org_mozilla_xpcom_internal_XPCOMImpl_##func##Native +#define XPCOM_NATIVE2(func) Java_org_mozilla_xpcom_internal_XPCOMImpl_##func +#else +#define MOZILLA_NATIVE(func) Java_org_mozilla_xpcom_internal_MozillaImpl_##func +#define GRE_NATIVE(func) Java_org_mozilla_xpcom_internal_GREImpl_##func +#define XPCOM_NATIVE(func) Java_org_mozilla_xpcom_internal_XPCOMImpl_##func +#endif +#define JAVAPROXY_NATIVE(func) \ + Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_##func +#define LOCKPROXY_NATIVE(func) Java_org_mozilla_xpcom_ProfileLock_##func +#define JXUTILS_NATIVE(func) \ + Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_##func + + +extern "C" NS_EXPORT void JNICALL +MOZILLA_NATIVE(initialize) (JNIEnv* env, jobject); + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(initEmbedding) (JNIEnv* env, jobject, jobject aLibXULDirectory, + jobject aAppDirectory, jobject aAppDirProvider); + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(termEmbedding) (JNIEnv *env, jobject); + +extern "C" NS_EXPORT jobject JNICALL +GRE_NATIVE(lockProfileDirectory) (JNIEnv *, jobject, jobject aDirectory); + +extern "C" NS_EXPORT void JNICALL +GRE_NATIVE(notifyProfile) (JNIEnv *env, jobject); + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(initXPCOM) (JNIEnv* env, jobject, jobject aMozBinDirectory, + jobject aAppFileLocProvider); + +extern "C" NS_EXPORT void JNICALL +XPCOM_NATIVE(shutdownXPCOM) (JNIEnv *env, jobject, jobject aServMgr); + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(newLocalFile) (JNIEnv *env, jobject, jstring aPath, + jboolean aFollowLinks); + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(getComponentManager) (JNIEnv *env, jobject); + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(getComponentRegistrar) (JNIEnv *env, jobject); + +extern "C" NS_EXPORT jobject JNICALL +XPCOM_NATIVE(getServiceManager) (JNIEnv *env, jobject); + +extern "C" NS_EXPORT jobject JNICALL +JAVAPROXY_NATIVE(callXPCOMMethod) (JNIEnv *env, jclass that, jobject aJavaProxy, + jstring aMethodName, jobjectArray aParams); + +extern "C" NS_EXPORT void JNICALL +JAVAPROXY_NATIVE(finalizeProxy) (JNIEnv *env, jclass that, jobject aJavaProxy); + +extern "C" NS_EXPORT jboolean JNICALL +JAVAPROXY_NATIVE(isSameXPCOMObject) (JNIEnv *env, jclass that, jobject aProxy1, + jobject aProxy2); + +extern "C" NS_EXPORT void JNICALL +LOCKPROXY_NATIVE(release) (JNIEnv *env, jclass that, jlong aLockObject); + +extern "C" NS_EXPORT jlong JNICALL +MOZILLA_NATIVE(getNativeHandleFromAWT) (JNIEnv* env, jobject, jobject widget); + +extern "C" NS_EXPORT jlong JNICALL +JXUTILS_NATIVE(wrapJavaObject) (JNIEnv* env, jobject, jobject aJavaObject, + jstring aIID); + +extern "C" NS_EXPORT jobject JNICALL +JXUTILS_NATIVE(wrapXPCOMObject) (JNIEnv* env, jobject, jlong aXPCOMObject, + jstring aIID); + +#endif // _nsJavaInterfaces_h_ diff --git a/src/libs/xpcom18a4/java/src/nsJavaWrapper.cpp b/src/libs/xpcom18a4/java/src/nsJavaWrapper.cpp new file mode 100644 index 00000000..a046c8a3 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaWrapper.cpp @@ -0,0 +1,2020 @@ +/* ***** 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 ***** */ + +#include "nsJavaInterfaces.h" +#include "nsJavaWrapper.h" +#include "nsJavaXPTCStub.h" +#include "nsJavaXPCOMBindingUtils.h" +#include "jni.h" +#include "xptcall.h" +#include "nsIInterfaceInfoManager.h" +#include "nsString.h" +#include "nsCRT.h" +#include "prmem.h" +#include "nsServiceManagerUtils.h" +#include "nsThreadUtils.h" +#include "nsProxyRelease.h" + +static nsID nullID = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}}; + +#ifdef VBOX +#include "nsIThread.h" +static nsresult +NS_InvokeByIndex(nsISupports* that, PRUint32 methodIndex, + PRUint32 paramCount, nsXPTCVariant* params) +{ + return XPTC_InvokeByIndex(that, methodIndex, paramCount, params); +} + +#endif + +nsresult +CreateJavaArray(JNIEnv* env, PRUint8 aType, PRUint32 aSize, const nsID& aIID, + jobject* aResult) +{ + jobject array = nsnull; + switch (aType) + { + case nsXPTType::T_I8: + array = env->NewByteArray(aSize); + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + array = env->NewShortArray(aSize); + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + array = env->NewIntArray(aSize); + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + array = env->NewLongArray(aSize); + break; + + case nsXPTType::T_FLOAT: + array = env->NewFloatArray(aSize); + break; + + // XXX how do we handle unsigned 64-bit values? + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + array = env->NewDoubleArray(aSize); + break; + + case nsXPTType::T_BOOL: + array = env->NewBooleanArray(aSize); + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + array = env->NewCharArray(aSize); + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + case nsXPTType::T_IID: + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + array = env->NewObjectArray(aSize, stringClass, nsnull); + break; + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID)); + NS_ASSERTION(iim, "Failed to get InterfaceInfoManager"); + if (!iim) + return NS_ERROR_FAILURE; + + // Get interface info for given IID + nsCOMPtr info; + nsresult rv = iim->GetInfoForIID(&aIID, getter_AddRefs(info)); + if (NS_FAILED(rv)) + return rv; + + // Get interface name + const char* iface_name; + rv = info->GetNameShared(&iface_name); + if (NS_FAILED(rv)) + return rv; + + // Create proper Java interface name + nsCAutoString class_name("org/mozilla/interfaces/"); + class_name.AppendASCII(iface_name); + jclass ifaceClass = env->FindClass(class_name.get()); + if (!ifaceClass) + return NS_ERROR_FAILURE; + + array = env->NewObjectArray(aSize, ifaceClass, nsnull); + break; + } + + case nsXPTType::T_VOID: + array = env->NewLongArray(aSize); + break; + + default: + NS_WARNING("unknown type"); + return NS_ERROR_FAILURE; + } + + if (!array) + return NS_ERROR_OUT_OF_MEMORY; + + *aResult = array; + return NS_OK; +} + +nsresult +GetNativeArrayElement(PRUint8 aType, void* aArray, PRUint32 aIndex, + nsXPTCVariant* aResult) +{ + switch (aType) + { + case nsXPTType::T_I8: + case nsXPTType::T_U8: + aResult->val.u8 = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U16: + aResult->val.u16 = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U32: + aResult->val.u32 = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U64: + aResult->val.u64 = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_FLOAT: + aResult->val.f = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_DOUBLE: + aResult->val.d = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_BOOL: + aResult->val.b = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_CHAR: + aResult->val.c = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_WCHAR: + aResult->val.wc = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_CHAR_STR: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_WCHAR_STR: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_IID: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + case nsXPTType::T_VOID: + aResult->val.p = static_cast(aArray)[aIndex]; + break; + + default: + NS_WARNING("unknown type"); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +nsresult +CreateNativeArray(PRUint8 aType, PRUint32 aSize, void** aResult) +{ + void* array = nsnull; + switch (aType) + { + case nsXPTType::T_I8: + case nsXPTType::T_U8: + array = PR_Malloc(aSize * sizeof(PRUint8)); + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U16: + array = PR_Malloc(aSize * sizeof(PRUint16)); + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U32: + array = PR_Malloc(aSize * sizeof(PRUint32)); + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U64: + array = PR_Malloc(aSize * sizeof(PRUint64)); + break; + + case nsXPTType::T_FLOAT: + array = PR_Malloc(aSize * sizeof(float)); + break; + + case nsXPTType::T_DOUBLE: + array = PR_Malloc(aSize * sizeof(double)); + break; + + case nsXPTType::T_BOOL: + array = PR_Malloc(aSize * sizeof(PRBool)); + break; + + case nsXPTType::T_CHAR: + array = PR_Malloc(aSize * sizeof(char)); + break; + + case nsXPTType::T_WCHAR: + array = PR_Malloc(aSize * sizeof(PRUnichar)); + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + case nsXPTType::T_IID: + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + array = PR_Malloc(aSize * sizeof(void*)); + break; + + case nsXPTType::T_VOID: + array = PR_Malloc(aSize * sizeof(void*)); + break; + + default: + NS_WARNING("unknown type"); + return NS_ERROR_FAILURE; + } + + if (!array) + return NS_ERROR_OUT_OF_MEMORY; + + *aResult = array; + return NS_OK; +} + +/** + * Handle 'in' and 'inout' params. + */ +nsresult +SetupParams(JNIEnv *env, const jobject aParam, PRUint8 aType, PRBool aIsOut, + const nsID& aIID, PRUint8 aArrayType, PRUint32 aArraySize, + PRBool aIsArrayElement, PRUint32 aIndex, nsXPTCVariant &aVariant) +{ + nsresult rv = NS_OK; + + switch (aType) + { + case nsXPTType::T_I8: + { + LOG(("byte\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.i8 = env->CallByteMethod(aParam, byteValueMID); + } else { // 'inout' & 'array' + jbyte value; + if (aParam) { + env->GetByteArrayRegion((jbyteArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.i8 = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_I16: + case nsXPTType::T_U8: // C++ unsigned octet <=> Java short + { + LOG(("short\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + jshort value = env->CallShortMethod(aParam, shortValueMID); + if (aType == nsXPTType::T_I16) + aVariant.val.i16 = value; + else + aVariant.val.u8 = value; + } else { // 'inout' & 'array' + jshort value; + if (aParam) { + env->GetShortArrayRegion((jshortArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + if (aType == nsXPTType::T_I16) + aVariant.val.i16 = value; + else + aVariant.val.u8 = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + if (aType == nsXPTType::T_I16) + static_cast(aVariant.val.p)[aIndex] = value; + else + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_I32: + case nsXPTType::T_U16: // C++ unsigned short <=> Java int + { + LOG(("int\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + jint value = env->CallIntMethod(aParam, intValueMID); + if (aType == nsXPTType::T_I32) + aVariant.val.i32 = value; + else + aVariant.val.u16 = value; + } else { // 'inout' & 'array' + jint value; + if (aParam) { + env->GetIntArrayRegion((jintArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + if (aType == nsXPTType::T_I32) + aVariant.val.i32 = value; + else + aVariant.val.u16 = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + if (aType == nsXPTType::T_I32) + static_cast(aVariant.val.p)[aIndex] = value; + else + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_I64: + case nsXPTType::T_U32: // C++ unsigned int <=> Java long + { + LOG(("long\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + jlong value = env->CallLongMethod(aParam, longValueMID); + if (aType == nsXPTType::T_I64) + aVariant.val.i64 = value; + else + aVariant.val.u32 = value; + } else { // 'inout' & 'array' + jlong value; + if (aParam) { + env->GetLongArrayRegion((jlongArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + if (aType == nsXPTType::T_I64) + aVariant.val.i64 = value; + else + aVariant.val.u32 = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + if (aType == nsXPTType::T_I64) + static_cast(aVariant.val.p)[aIndex] = value; + else + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_FLOAT: + { + LOG(("float\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.f = env->CallFloatMethod(aParam, floatValueMID); + } else { // 'inout' & 'array' + jfloat value; + if (aParam) { + env->GetFloatArrayRegion((jfloatArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.f = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + // XXX how do we handle unsigned 64-bit value? + case nsXPTType::T_U64: // C++ unsigned long <=> Java double + case nsXPTType::T_DOUBLE: + { + LOG(("double\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + jdouble value = env->CallDoubleMethod(aParam, doubleValueMID); + if (aType == nsXPTType::T_DOUBLE) + aVariant.val.d = value; + else + aVariant.val.u64 = static_cast(value); + } else { // 'inout' & 'array' + jdouble value; + if (aParam) { + env->GetDoubleArrayRegion((jdoubleArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + if (aType == nsXPTType::T_DOUBLE) + aVariant.val.d = value; + else + aVariant.val.u64 = static_cast(value); + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + if (aType == nsXPTType::T_DOUBLE) + static_cast(aVariant.val.p)[aIndex] = value; + else + static_cast(aVariant.val.p)[aIndex] = + static_cast(value); + } + } + break; + } + + case nsXPTType::T_BOOL: + { + LOG(("boolean\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.b = env->CallBooleanMethod(aParam, booleanValueMID); + } else { // 'inout' & 'array' + jboolean value; + if (aParam) { + env->GetBooleanArrayRegion((jbooleanArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.b = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_CHAR: + { + LOG(("char\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.c = env->CallCharMethod(aParam, charValueMID); + } else { // 'inout' & 'array' + jchar value; + if (aParam) { + env->GetCharArrayRegion((jcharArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.c = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_WCHAR: + { + LOG(("char\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.wc = env->CallCharMethod(aParam, charValueMID); + } else { // 'inout' & 'array' + jchar value; + if (aParam) { + env->GetCharArrayRegion((jcharArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.wc = value; + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = value; + } + } + break; + } + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + { + LOG(("String\n")); + jstring data = nsnull; + if (!aIsOut && !aIsArrayElement) { // 'in' + data = (jstring) aParam; + } else if (aParam) { // 'inout' & 'array' + data = (jstring) env->GetObjectArrayElement((jobjectArray) aParam, + aIndex); + } + + void* buf = nsnull; + if (data) { + jsize uniLength = env->GetStringLength(data); + if (uniLength > 0) { + if (aType == nsXPTType::T_CHAR_STR) { + jsize utf8Length = env->GetStringUTFLength(data); + buf = nsMemory::Alloc((utf8Length + 1) * sizeof(char)); + if (!buf) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + char* char_str = static_cast(buf); + env->GetStringUTFRegion(data, 0, uniLength, char_str); + char_str[utf8Length] = '\0'; + + } else { // if T_WCHAR_STR + buf = nsMemory::Alloc((uniLength + 1) * sizeof(jchar)); + if (!buf) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + jchar* jchar_str = static_cast(buf); + env->GetStringRegion(data, 0, uniLength, jchar_str); + jchar_str[uniLength] = '\0'; + } + } else { + // create empty string + buf = nsMemory::Alloc(2); + if (!buf) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + ((jchar*)buf)[0] = '\0'; + } + } + + if (!aIsArrayElement) { // 'in' & 'inout' + aVariant.val.p = buf; + if (aIsOut) { // 'inout' + aVariant.ptr = &aVariant.val; + aVariant.SetPtrIsData(); + } + } else { // 'array' + if (aType == nsXPTType::T_CHAR_STR) { + char* str = static_cast(buf); + static_cast(aVariant.val.p)[aIndex] = str; + } else { + PRUnichar* str = static_cast(buf); + static_cast(aVariant.val.p)[aIndex] = str; + } + } + break; + } + + case nsXPTType::T_IID: + { + LOG(("String(IID)\n")); + jstring data = nsnull; + if (!aIsOut && !aIsArrayElement) { // 'in' + data = (jstring) aParam; + } else if (aParam) { // 'inout' & 'array' + data = (jstring) env->GetObjectArrayElement((jobjectArray) aParam, + aIndex); + } + + nsID* iid = new nsID; + if (!iid) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + if (data) { + // extract IID string from Java string + const char* str = env->GetStringUTFChars(data, nsnull); + if (!str) { + delete iid; + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + // parse string into IID object + iid->Parse(str); + env->ReleaseStringUTFChars(data, str); + } else { + *iid = nullID; + } + + if (!aIsArrayElement) { // 'in' & 'inout' + aVariant.val.p = iid; + if (aIsOut) { // 'inout' + aVariant.ptr = &aVariant.val; + aVariant.SetPtrIsData(); + } + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = iid; + } + break; + } + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + LOG(("nsISupports\n")); + jobject java_obj = nsnull; + if (!aIsOut && !aIsArrayElement) { // 'in' + java_obj = (jobject) aParam; + } else if (aParam) { // 'inout' & 'array' + java_obj = (jobject) env->GetObjectArrayElement((jobjectArray) aParam, + aIndex); + } + + void* xpcom_obj; + if (java_obj) { + // If the requested interface is nsIWeakReference, then we look for or + // create a stub for the nsISupports interface. Then we create a weak + // reference from that stub. + PRBool isWeakRef; + nsID iid; + if (aIID.Equals(NS_GET_IID(nsIWeakReference))) { + isWeakRef = PR_TRUE; + iid = NS_GET_IID(nsISupports); + } else { + isWeakRef = PR_FALSE; + iid = aIID; + } + + rv = JavaObjectToNativeInterface(env, java_obj, iid, &xpcom_obj); + if (NS_FAILED(rv)) + break; + NS_ENSURE_TRUE(xpcom_obj, NS_ERROR_FAILURE); + nsISupports *xpcom_nat_obj = (nsISupports*) xpcom_obj; + rv = xpcom_nat_obj->QueryInterface(iid, &xpcom_obj); + NS_IF_RELEASE(xpcom_nat_obj); + if (NS_FAILED(rv)) + break; + + // If the function expects a weak reference, then we need to + // create it here. + if (isWeakRef) { + nsISupports* isupports = (nsISupports*) xpcom_obj; + nsCOMPtr supportsweak = + do_QueryInterface(isupports); + if (supportsweak) { + nsWeakPtr weakref; + supportsweak->GetWeakReference(getter_AddRefs(weakref)); + NS_RELEASE(isupports); + xpcom_obj = weakref; + NS_ADDREF((nsISupports*) xpcom_obj); + } else { + xpcom_obj = nsnull; + } + } + } else { + xpcom_obj = nsnull; + } + + if (!aIsArrayElement) { // 'in' & 'inout' + aVariant.val.p = xpcom_obj; + aVariant.SetValIsInterface(); + if (aIsOut) { // 'inout' + aVariant.ptr = &aVariant.val; + aVariant.SetPtrIsData(); + } + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = xpcom_obj; + } + break; + } + + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + { + LOG(("String\n")); + // Expecting only 'in' and 'in dipper' + NS_PRECONDITION(!aIsOut, "unexpected param descriptor"); + if (aIsOut) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + jstring jstr = static_cast(aParam); + nsAString* str = jstring_to_nsAString(env, jstr); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + aVariant.val.p = str; + aVariant.SetValIsDOMString(); + break; + } + + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + { + LOG(("StringUTF\n")); + // Expecting only 'in' and 'in dipper' + NS_PRECONDITION(!aIsOut, "unexpected param descriptor"); + if (aIsOut) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + jstring jstr = static_cast(aParam); + nsACString* str = jstring_to_nsACString(env, jstr); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + aVariant.val.p = str; + if (aType == nsXPTType::T_CSTRING) { + aVariant.SetValIsCString(); + } else { + aVariant.SetValIsUTF8String(); + } + break; + } + + // handle "void *" as an "long" in Java + case nsXPTType::T_VOID: + { + LOG(("long (void*)\n")); + if (!aIsOut && !aIsArrayElement) { // 'in' + aVariant.val.p = + reinterpret_cast(env->CallLongMethod(aParam, longValueMID)); + } else { // 'inout' & 'array' + jlong value; + if (aParam) { + env->GetLongArrayRegion((jlongArray) aParam, aIndex, 1, &value); + } + + if (aIsOut) { // 'inout' + if (aParam) { + aVariant.val.p = reinterpret_cast(value); + aVariant.ptr = &aVariant.val; + } else { + aVariant.ptr = nsnull; + } + aVariant.SetPtrIsData(); + } else { // 'array' + static_cast(aVariant.val.p)[aIndex] = + reinterpret_cast(value); + } + } + break; + } + + case nsXPTType::T_ARRAY: + { + jobject sourceArray = nsnull; + if (!aIsOut) { // 'in' + sourceArray = aParam; + } else if (aParam) { // 'inout' + jobjectArray array = static_cast(aParam); + sourceArray = env->GetObjectArrayElement(array, 0); + } + + if (sourceArray) { + rv = CreateNativeArray(aArrayType, aArraySize, &aVariant.val.p); + + for (PRUint32 i = 0; i < aArraySize && NS_SUCCEEDED(rv); i++) { + rv = SetupParams(env, sourceArray, aArrayType, PR_FALSE, aIID, 0, 0, + PR_TRUE, i, aVariant); + } + } + + if (aIsOut) { // 'inout' + aVariant.ptr = &aVariant.val.p; + aVariant.SetPtrIsData(); + } + break; + } + + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + { + NS_PRECONDITION(!aIsArrayElement, "sized string array not supported"); + + LOG(("Sized string\n")); + jstring data = nsnull; + if (!aIsOut) { // 'in' + data = (jstring) aParam; + } else if (aParam) { // 'inout' + data = (jstring) env->GetObjectArrayElement((jobjectArray) aParam, + aIndex); + } + + PRUint32 length = 0; + if (data) { + if (aType == nsXPTType::T_PSTRING_SIZE_IS) { + length = env->GetStringUTFLength(data); + } else { + length = env->GetStringLength(data); + } + if (length > aArraySize) { + rv = NS_ERROR_ILLEGAL_VALUE; + break; + } + } + + PRUint32 size_of_char = (aType == nsXPTType::T_PSTRING_SIZE_IS) ? + sizeof(char) : sizeof(jchar); + PRUint32 allocLength = (aArraySize + 1) * size_of_char; + void* buf = nsMemory::Alloc(allocLength); + if (!buf) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + if (data) { + if (aType == nsXPTType::T_PSTRING_SIZE_IS) { + const char* str = env->GetStringUTFChars(data, nsnull); + if (!str) { + nsMemory::Free(buf); + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + memcpy(buf, str, length); + env->ReleaseStringUTFChars(data, str); + } else { + jchar* jchar_str = static_cast(buf); + env->GetStringRegion(data, 0, length, jchar_str); + } + } + + aVariant.val.p = buf; + if (aIsOut) { // 'inout' + aVariant.ptr = &aVariant.val; + aVariant.SetPtrIsData(); + } + + break; + } + + default: + NS_WARNING("unexpected parameter type"); + return NS_ERROR_UNEXPECTED; + } + + return rv; +} + +/** + * Does any cleanup from objects created in SetupParams, as well as converting + * any out params to Java. + * + * NOTE: If aInvokeResult is an error condition, then we just do cleanup in + * this function. + */ +nsresult +FinalizeParams(JNIEnv *env, const nsXPTParamInfo &aParamInfo, PRUint8 aType, + nsXPTCVariant &aVariant, const nsID& aIID, + PRBool aIsArrayElement, PRUint8 aArrayType, PRUint32 aArraySize, + PRUint32 aIndex, nsresult aInvokeResult, jobject* aParam) +{ + nsresult rv = NS_OK; + + switch (aType) + { + case nsXPTType::T_I8: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jbyte value = aVariant.val.i8; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(byteClass, byteInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetByteArrayRegion((jbyteArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jshort value = (aType == nsXPTType::T_I16) ? aVariant.val.i16 : + aVariant.val.u8; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(shortClass, shortInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetShortArrayRegion((jshortArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jint value = (aType == nsXPTType::T_I32) ? aVariant.val.i32 : + aVariant.val.u16; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(intClass, intInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetIntArrayRegion((jintArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jlong value = (aType == nsXPTType::T_I64) ? aVariant.val.i64 : + aVariant.val.u32; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(longClass, longInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetLongArrayRegion((jlongArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_FLOAT: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jfloat value = aVariant.val.f; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(floatClass, floatInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetFloatArrayRegion((jfloatArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + // XXX how do we handle unsigned 64-bit values? + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jdouble value = (aType == nsXPTType::T_DOUBLE) ? aVariant.val.d : + aVariant.val.u64; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(doubleClass, doubleInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetDoubleArrayRegion((jdoubleArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_BOOL: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jboolean value = aVariant.val.b; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(booleanClass, booleanInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetBooleanArrayRegion((jbooleanArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jchar value; + if (aType == nsXPTType::T_CHAR) + value = aVariant.val.c; + else + value = aVariant.val.wc; + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(charClass, charInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetCharArrayRegion((jcharArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + { + if ((aParamInfo.IsOut() || aIsArrayElement) && + NS_SUCCEEDED(aInvokeResult)) + { + // create new string from data + jstring str = nsnull; + if (aVariant.val.p) { + if (aType == nsXPTType::T_CHAR_STR) { + str = env->NewStringUTF((const char*) aVariant.val.p); + } else { + PRUint32 length = nsCRT::strlen((const PRUnichar*) aVariant.val.p); + str = env->NewString((const jchar*) aVariant.val.p, length); + } + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = str; + } else if (*aParam) { + // put new string into output array + env->SetObjectArrayElement((jobjectArray) *aParam, aIndex, str); + } + } + + // cleanup + if (aVariant.val.p) + nsMemory::Free(aVariant.val.p); + break; + } + + case nsXPTType::T_IID: + { + nsID* iid = static_cast(aVariant.val.p); + + if ((aParamInfo.IsOut() || aIsArrayElement) && + NS_SUCCEEDED(aInvokeResult)) + { + // Create the string from nsID + jstring str = nsnull; + if (iid) { + char iid_str[NSID_LENGTH]; + iid->ToProvidedString(iid_str); + str = env->NewStringUTF(iid_str); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = str; + } else if (*aParam) { + // put new string into output array + env->SetObjectArrayElement((jobjectArray) *aParam, aIndex, str); + } + } + + // Ordinarily, we would delete 'iid' here. But we cannot do that until + // we've handled all of the params. See comment in CallXPCOMMethod. + // We can safely delete array elements, though. + if (aIsArrayElement) + delete iid; + + break; + } + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + nsISupports* xpcom_obj = static_cast(aVariant.val.p); + + if ((aParamInfo.IsOut() || aIsArrayElement) && + NS_SUCCEEDED(aInvokeResult)) + { + jobject java_obj = nsnull; + if (xpcom_obj) { + // Get matching Java object for given xpcom object + rv = NativeInterfaceToJavaObject(env, xpcom_obj, aIID, nsnull, + &java_obj); + if (NS_FAILED(rv)) + break; + } + + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = java_obj; + } else if (*aParam) { + // put new Java object into output array + env->SetObjectArrayElement((jobjectArray) *aParam, aIndex, java_obj); + } + } + + // cleanup + NS_IF_RELEASE(xpcom_obj); + break; + } + + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + { + NS_PRECONDITION(aParamInfo.IsIn(), "unexpected param descriptor"); + if (!aParamInfo.IsIn()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + nsString* str = static_cast(aVariant.val.p); + if (NS_SUCCEEDED(aInvokeResult) && aParamInfo.IsDipper()) { + // Create Java string from returned nsString + jstring jstr = nsnull; + if (str && !str->IsVoid()) { + jstr = env->NewString((const jchar*) str->get(), str->Length()); + if (!jstr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + *aParam = jstr; + } + + // cleanup + if (str) { + delete str; + } + break; + } + + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + { + NS_PRECONDITION(aParamInfo.IsIn(), "unexpected param descriptor"); + if (!aParamInfo.IsIn()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + nsCString* str = static_cast(aVariant.val.p); + if (NS_SUCCEEDED(aInvokeResult) && aParamInfo.IsDipper()) { + // Create Java string from returned nsString + jstring jstr = nsnull; + if (str && !str->IsVoid()) { + jstr = env->NewStringUTF((const char*) str->get()); + if (!jstr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + *aParam = jstr; + } + + // cleanup + if (str) { + delete str; + } + break; + } + + case nsXPTType::T_VOID: + { + if (NS_SUCCEEDED(aInvokeResult)) { + jlong value = reinterpret_cast(aVariant.val.p); + if (aParamInfo.IsRetval() && !aIsArrayElement) { + *aParam = env->NewObject(longClass, longInitMID, value); + } else if ((aParamInfo.IsOut() || aIsArrayElement) && *aParam) { + env->SetLongArrayRegion((jlongArray) *aParam, aIndex, 1, &value); + } + } + break; + } + + case nsXPTType::T_ARRAY: + { + if (aParamInfo.IsOut() && NS_SUCCEEDED(aInvokeResult)) { + // Create Java array from returned native array + jobject jarray = nsnull; + if (aVariant.val.p) { + rv = CreateJavaArray(env, aArrayType, aArraySize, aIID, &jarray); + if (NS_FAILED(rv)) + break; + + nsXPTCVariant var; + for (PRUint32 i = 0; i < aArraySize && NS_SUCCEEDED(rv); i++) { + rv = GetNativeArrayElement(aArrayType, aVariant.val.p, i, &var); + if (NS_SUCCEEDED(rv)) { + rv = FinalizeParams(env, aParamInfo, aArrayType, var, aIID, + PR_TRUE, 0, 0, i, aInvokeResult, &jarray); + } + } + } + + if (aParamInfo.IsRetval()) { + *aParam = jarray; + } else if (*aParam) { + // put new Java array into output array + env->SetObjectArrayElement((jobjectArray) *aParam, 0, jarray); + } + } + + // cleanup + // If this is not an out param or if the invokeResult is a failure case, + // then the array elements have not been cleaned up. Do so now. + if (!aParamInfo.IsOut() || (NS_FAILED(aInvokeResult) && aVariant.val.p)) { + nsXPTCVariant var; + for (PRUint32 i = 0; i < aArraySize; i++) { + rv = GetNativeArrayElement(aArrayType, aVariant.val.p, i, &var); + if (NS_SUCCEEDED(rv)) { + FinalizeParams(env, aParamInfo, aArrayType, var, aIID, PR_TRUE, + 0, 0, i, NS_ERROR_FAILURE, nsnull); + } + } + } + PR_Free(aVariant.val.p); + break; + } + + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + { + NS_PRECONDITION(!aIsArrayElement, "sized string array not supported"); + + if ((aParamInfo.IsOut()) && NS_SUCCEEDED(aInvokeResult)) + { + // create new string from data + jstring str = nsnull; + if (aVariant.val.p) { + if (aType == nsXPTType::T_PSTRING_SIZE_IS) { + PRUint32 len = (aArraySize + 1) * sizeof(char); + char* buf = (char*) nsMemory::Alloc(len); + if (buf) { + memcpy(buf, aVariant.val.p, len); + buf[aArraySize] = '\0'; + str = env->NewStringUTF((const char*) buf); + nsMemory::Free(buf); + } + } else { + str = env->NewString((const jchar*) aVariant.val.p, aArraySize); + } + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + if (aParamInfo.IsRetval()) { + *aParam = str; + } else if (*aParam) { + // put new string into output array + env->SetObjectArrayElement((jobjectArray) *aParam, aIndex, str); + } + } + + // cleanup + if (aVariant.val.p) + nsMemory::Free(aVariant.val.p); + break; + } + + default: + NS_WARNING("unexpected parameter type"); + return NS_ERROR_UNEXPECTED; + } + + // Check for Java exception, but don't overwrite pre-existing error code. + if (NS_SUCCEEDED(rv) && env->ExceptionCheck()) + rv = NS_ERROR_FAILURE; + + return rv; +} + +nsresult +QueryAttributeInfo(nsIInterfaceInfo* aIInfo, const char* aMethodName, + PRBool aCapitalizedAttr, PRUint16* aMethodIndex, + const nsXPTMethodInfo** aMethodInfo) + +{ + nsresult rv = NS_ERROR_FAILURE; + + // An 'attribute' will start with either "get" or "set". But first, + // we check the length, in order to skip over method names that match exactly + // "get" or "set". + if (strlen(aMethodName) > 3) { + if (strncmp("get", aMethodName, 3) == 0) { + char* getterName = strdup(aMethodName + 3); + if (!aCapitalizedAttr) { + getterName[0] = tolower(getterName[0]); + } + rv = aIInfo->GetMethodInfoForName(getterName, aMethodIndex, aMethodInfo); + free(getterName); + } else if (strncmp("set", aMethodName, 3) == 0) { + char* setterName = strdup(aMethodName + 3); + if (!aCapitalizedAttr) { + setterName[0] = tolower(setterName[0]); + } + rv = aIInfo->GetMethodInfoForName(setterName, aMethodIndex, aMethodInfo); + if (NS_SUCCEEDED(rv)) { + // If this succeeded, GetMethodInfoForName will have returned the + // method info for the 'getter'. We want the 'setter', so increase + // method index by one ('setter' immediately follows the 'getter'), + // and get its method info. + (*aMethodIndex)++; + rv = aIInfo->GetMethodInfo(*aMethodIndex, aMethodInfo); + if (NS_SUCCEEDED(rv)) { + // Double check that this methodInfo matches the given method. + if (!(*aMethodInfo)->IsSetter() || + strcmp(setterName, (*aMethodInfo)->name) != 0) { + rv = NS_ERROR_FAILURE; + } + } + } + free(setterName); + } + } + + return rv; +} + +/** + * Given an interface info struct and a method name, returns the method info + * and index, if that method exists. + * + * Most method names are lower case. Unfortunately, the method names of some + * interfaces (such as nsIAppShell) start with a capital letter. This function + * will try all of the permutations. + */ +nsresult +QueryMethodInfo(nsIInterfaceInfo* aIInfo, const char* aMethodName, + PRUint16* aMethodIndex, const nsXPTMethodInfo** aMethodInfo) +{ + // Skip over any leading underscores, since these are methods that conflicted + // with existing Java keywords + const char* methodName = aMethodName; + if (methodName[0] == '_') { + methodName++; + } + + // The common case is that the method name is lower case, so we check + // that first. + nsresult rv; + rv = aIInfo->GetMethodInfoForName(methodName, aMethodIndex, aMethodInfo); + if (NS_SUCCEEDED(rv)) + return rv; + + // If there is no method called , then maybe it is an + // 'attribute'. + rv = QueryAttributeInfo(aIInfo, methodName, PR_FALSE, aMethodIndex, + aMethodInfo); + if (NS_SUCCEEDED(rv)) + return rv; + + // If we get here, then maybe the method name is capitalized. + char* name = strdup(methodName); + name[0] = toupper(name[0]); + rv = aIInfo->GetMethodInfoForName(name, aMethodIndex, aMethodInfo); + free(name); + if (NS_SUCCEEDED(rv)) + return rv; + + // If there is no method called , then maybe it is an + // 'attribute'. + rv = QueryAttributeInfo(aIInfo, methodName, PR_TRUE, aMethodIndex, + aMethodInfo); + + return rv; +} + +#ifdef VBOX +#include +#include +#include "nspr.h" + +static void makeErrorMessage(nsresult r, char* msg, size_t msgSize) +{ + bool gotMsg = false; + + if (!gotMsg) + { + nsresult rc; + nsCOMPtr es; + es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rc); + if (NS_SUCCEEDED (rc)) + { + nsCOMPtr em; + rc = es->GetCurrentExceptionManager (getter_AddRefs (em)); + if (NS_SUCCEEDED (rc)) + { + nsCOMPtr ex; + rc = em->GetCurrentException(getter_AddRefs (ex)); + if (NS_SUCCEEDED (rc) && ex) + { + nsXPIDLCString emsg; + ex->GetMessage(getter_Copies(emsg)); + PR_snprintf(msg, msgSize, "%s", + emsg.get()); + gotMsg = true; + } + } + } + } + + if (!gotMsg) + { + const RTCOMERRMSG* pMsg = RTErrCOMGet(r); + if (strncmp(pMsg->pszMsgFull, "Unknown", 7) != 0) + { + PR_snprintf(msg, msgSize, "%s (%s)", + pMsg->pszMsgFull, pMsg->pszDefine); + gotMsg = true; + } + } + + if (!gotMsg) + { + PR_snprintf(msg, msgSize, "Error 0x%x in module 0x%x", + NS_ERROR_GET_CODE(r), NS_ERROR_GET_MODULE(r)); + } +} +#endif + +/** + * org.mozilla.xpcom.XPCOMJavaProxy.internal.callXPCOMMethod + */ +extern "C" NS_EXPORT jobject JNICALL +JAVAPROXY_NATIVE(callXPCOMMethod) (JNIEnv *env, jclass that, jobject aJavaProxy, + jstring aMethodName, jobjectArray aParams) +{ + nsresult rv; + + // Get native XPCOM instance + void* xpcom_obj; + rv = GetXPCOMInstFromProxy(env, aJavaProxy, &xpcom_obj); + if (NS_FAILED(rv)) { + ThrowException(env, 0, "Failed to get matching XPCOM object"); + return nsnull; + } + JavaXPCOMInstance* inst = static_cast(xpcom_obj); + + // Get method info + PRUint16 methodIndex; + const nsXPTMethodInfo* methodInfo; + nsIInterfaceInfo* iinfo = inst->InterfaceInfo(); + const char* methodName = env->GetStringUTFChars(aMethodName, nsnull); + rv = QueryMethodInfo(iinfo, methodName, &methodIndex, &methodInfo); + env->ReleaseStringUTFChars(aMethodName, methodName); + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "GetMethodInfoForName failed"); + return nsnull; + } + +#ifdef DEBUG_JAVAXPCOM + const char* ifaceName; + iinfo->GetNameShared(&ifaceName); + LOG(("===> (XPCOM) %s::%s()\n", ifaceName, methodInfo->GetName())); +#endif + + // Convert the Java params + PRUint8 paramCount = methodInfo->GetParamCount(); + nsXPTCVariant* params = nsnull; + if (paramCount) + { + params = new nsXPTCVariant[paramCount]; + if (!params) { + ThrowException(env, NS_ERROR_OUT_OF_MEMORY, "Can't create params array"); + return nsnull; + } + memset(params, 0, paramCount * sizeof(nsXPTCVariant)); + + PRBool foundDependentParam = PR_FALSE; + for (PRUint8 i = 0; i < paramCount && NS_SUCCEEDED(rv); i++) + { + LOG(("\t Param %d: ", i)); + const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(i); + params[i].type = paramInfo.GetType(); + + if (params[i].type.IsDependent() && paramInfo.IsIn()) { + foundDependentParam = PR_TRUE; + continue; + } + + if (paramInfo.IsIn()) { + PRUint8 type = params[i].type.TagPart(); + + // get IID for interface params + nsID iid; + if (type == nsXPTType::T_INTERFACE) { + rv = GetIIDForMethodParam(iinfo, methodInfo, paramInfo, type, + methodIndex, params, PR_TRUE, iid); + } + + if (NS_SUCCEEDED(rv)) { + jobject param = nsnull; + if (aParams && !paramInfo.IsRetval()) { + param = env->GetObjectArrayElement(aParams, i); + } + rv = SetupParams(env, param, type, paramInfo.IsOut(), iid, 0, 0, + PR_FALSE, 0, params[i]); + } + } else { + LOG(("out/retval\n")); + params[i].ptr = &(params[i].val); + params[i].SetPtrIsData(); + } + } + + // Handle any dependent params by doing a second pass + if (foundDependentParam) { + + for (PRUint8 j = 0; j < paramCount && NS_SUCCEEDED(rv); j++) { + + const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(j); + params[j].type = paramInfo.GetType(); + + if (!params[j].type.IsDependent()) + continue; + + if (paramInfo.IsIn()) { + PRUint8 type = params[j].type.TagPart(); + + // is paramater an array or sized string? + PRUint8 arrayType = 0; + PRUint32 arraySize = 0; + PRBool isArray = params[j].type.IsArray(); + PRBool isSizedString = isArray ? PR_FALSE : + type == nsXPTType::T_PSTRING_SIZE_IS || + type == nsXPTType::T_PWSTRING_SIZE_IS; + + if (isArray) { + // get array type + nsXPTType xpttype; + rv = iinfo->GetTypeForParam(methodIndex, ¶mInfo, 1, &xpttype); + if (NS_FAILED(rv)) + break; + arrayType = xpttype.TagPart(); + // IDL 'octet' arrays are not 'promoted' to short, but kept as 'byte'; + // therefore, treat as a signed 8bit value + if (arrayType == nsXPTType::T_U8) + arrayType = nsXPTType::T_I8; + } + + if (isArray || isSizedString) { + // get size of array or string + PRUint8 argnum; + rv = iinfo->GetSizeIsArgNumberForParam(methodIndex, ¶mInfo, 0, + &argnum); + if (NS_FAILED(rv)) + break; + arraySize = params[argnum].val.u32; + } + + // get IID for interface params + nsID iid; + if (type == nsXPTType::T_INTERFACE_IS || + (type == nsXPTType::T_ARRAY && + (arrayType == nsXPTType::T_INTERFACE || + arrayType == nsXPTType::T_INTERFACE_IS))) + { + PRUint8 paramType = type == nsXPTType::T_ARRAY ? arrayType : type; + rv = GetIIDForMethodParam(iinfo, methodInfo, paramInfo, paramType, + methodIndex, params, PR_TRUE, iid); + } + + if (NS_SUCCEEDED(rv)) { + jobject param = nsnull; + if (aParams && !paramInfo.IsRetval()) { + param = env->GetObjectArrayElement(aParams, j); + } + rv = SetupParams(env, param, type, paramInfo.IsOut(), iid, arrayType, + arraySize, PR_FALSE, 0, params[j]); + } + } + } + } + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "SetupParams failed"); + return nsnull; + } + } + + // Call the XPCOM method + const nsIID* iid; + iinfo->GetIIDShared(&iid); + nsISupports* realObject; + rv = inst->GetInstance()->QueryInterface(*iid, (void**) &realObject); + if (NS_FAILED(rv)) { + ThrowException(env, rv, "Failed to get real XPCOM object"); + return nsnull; + } + nsresult invokeResult = NS_InvokeByIndex(realObject, methodIndex, + paramCount, params); + NS_RELEASE(realObject); + + // Clean up params + jobject result = nsnull; + for (PRUint8 i = 0; i < paramCount && NS_SUCCEEDED(rv); i++) + { + const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(i); + PRUint8 type = paramInfo.GetType().TagPart(); + + // is paramater an array or sized string? + PRUint8 arrayType = 0; + PRUint32 arraySize = 0; + PRBool isArray = params[i].type.IsArray(); + PRBool isSizedString = isArray ? PR_FALSE : + type == nsXPTType::T_PSTRING_SIZE_IS || + type == nsXPTType::T_PWSTRING_SIZE_IS; + + if (isArray) { + // get array type + nsXPTType array_xpttype; + rv = iinfo->GetTypeForParam(methodIndex, ¶mInfo, 1, &array_xpttype); + if (NS_FAILED(rv)) + break; + arrayType = array_xpttype.TagPart(); + // IDL 'octet' arrays are not 'promoted' to short, but kept as 'byte'; + // therefore, treat as a signed 8bit value + if (arrayType == nsXPTType::T_U8) + arrayType = nsXPTType::T_I8; + } + + if (isArray || isSizedString) { + // get size of array + PRUint8 argnum; + rv = iinfo->GetSizeIsArgNumberForParam(methodIndex, ¶mInfo, 0, + &argnum); + if (NS_FAILED(rv)) + break; + arraySize = params[argnum].val.u32; + } + + // get IID for interface params + nsID iid; + if (type == nsXPTType::T_INTERFACE || type == nsXPTType::T_INTERFACE_IS || + (type == nsXPTType::T_ARRAY && (arrayType == nsXPTType::T_INTERFACE || + arrayType == nsXPTType::T_INTERFACE_IS))) + { + PRUint8 paramType = type == nsXPTType::T_ARRAY ? arrayType : type; + rv = GetIIDForMethodParam(iinfo, methodInfo, paramInfo, paramType, + methodIndex, params, PR_TRUE, iid); + if (NS_FAILED(rv)) + break; + } + + jobject* javaElement; + jobject element = nsnull; + if (!paramInfo.IsRetval()) { + element = env->GetObjectArrayElement(aParams, i); + javaElement = &element; + } else { + javaElement = &result; + } + rv = FinalizeParams(env, paramInfo, type, params[i], iid, PR_FALSE, + arrayType, arraySize, 0, invokeResult, javaElement); + } + + // Normally, we would delete any created nsID object in the above loop. + // However, GetIIDForMethodParam may need some of the nsID params when it's + // looking for the IID of an INTERFACE_IS. Therefore, we can't delete it + // until we've gone through the 'Finalize' loop once and created the result. + for (PRUint8 j = 0; j < paramCount; j++) + { + const nsXPTParamInfo ¶mInfo = methodInfo->GetParam(j); + const nsXPTType &type = paramInfo.GetType(); + if (type.TagPart() == nsXPTType::T_IID) { + nsID* iid = (nsID*) params[j].val.p; + delete iid; + } + } + + if (params) { + delete params; + } + + // If the XPCOM method invocation failed, we don't immediately throw an + // exception and return so that we can clean up any parameters. + if (NS_FAILED(invokeResult)) { + nsCAutoString message("The function \""); + message.AppendASCII(methodInfo->GetName()); + message.AppendLiteral("\" returned an error condition"); +#ifdef VBOX + char vboxMsg[1024]; + message.AppendLiteral(": \""); + makeErrorMessage(invokeResult, vboxMsg, sizeof vboxMsg); + message.AppendASCII(vboxMsg); + message.AppendLiteral("\""); +#endif + ThrowException(env, invokeResult, message.get()); + } + if (NS_FAILED(rv)) { + ThrowException(env, rv, "FinalizeParams failed"); + return nsnull; + } + + LOG(("<=== (XPCOM) %s::%s()\n", ifaceName, methodInfo->GetName())); + return result; +} + +nsresult +GetNewOrUsedJavaWrapper(JNIEnv* env, nsISupports* aXPCOMObject, + const nsIID& aIID, jobject aObjectLoader, + jobject* aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_NULL_POINTER; + + // Get the root nsISupports of the xpcom object + nsresult rv; + nsCOMPtr rootObject = do_QueryInterface(aXPCOMObject, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + // Get associated Java object from hash table + rv = gNativeToJavaProxyMap->Find(env, rootObject, aIID, aResult); + NS_ENSURE_SUCCESS(rv, rv); + if (*aResult) + return NS_OK; + + // No Java object is associated with the given XPCOM object, so we + // create a Java proxy. + + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID)); + NS_ASSERTION(iim, "Failed to get InterfaceInfoManager"); + if (!iim) + return NS_ERROR_FAILURE; + + // Get interface info for class + nsCOMPtr info; + rv = iim->GetInfoForIID(&aIID, getter_AddRefs(info)); + if (NS_FAILED(rv)) + return rv; + + // Wrap XPCOM object (addrefs rootObject) + JavaXPCOMInstance* inst = new JavaXPCOMInstance(rootObject, info); + if (!inst) + return NS_ERROR_OUT_OF_MEMORY; + + // Get interface name + const char* iface_name; + rv = info->GetNameShared(&iface_name); + + if (NS_SUCCEEDED(rv)) { + jobject java_obj = nsnull; + + // Create proper Java interface name + nsCAutoString class_name("org.mozilla.interfaces."); + class_name.AppendASCII(iface_name); + jclass ifaceClass = FindClassInLoader(env, aObjectLoader, class_name.get()); + + if (ifaceClass) { + java_obj = env->CallStaticObjectMethod(xpcomJavaProxyClass, + createProxyMID, ifaceClass, + reinterpret_cast(inst)); + if (env->ExceptionCheck()) + java_obj = nsnull; + } + + if (java_obj) { +#ifdef DEBUG_JAVAXPCOM + char* iid_str = aIID.ToString(); + LOG(("+ CreateJavaProxy (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + java_obj), + (PRUint32) rootObject, iid_str)); + PR_Free(iid_str); +#endif + + // Associate XPCOM object with Java proxy + rv = gNativeToJavaProxyMap->Add(env, rootObject, aIID, java_obj); + if (NS_SUCCEEDED(rv)) { + *aResult = java_obj; + return NS_OK; + } + } else { + rv = NS_ERROR_FAILURE; + } + } + + // If there was an error, clean up. + delete inst; + return rv; +} + +nsresult +GetXPCOMInstFromProxy(JNIEnv* env, jobject aJavaObject, void** aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_NULL_POINTER; + + jlong xpcom_obj = env->CallStaticLongMethod(xpcomJavaProxyClass, + getNativeXPCOMInstMID, aJavaObject); + + if (!xpcom_obj || env->ExceptionCheck()) { + return NS_ERROR_FAILURE; + } + + *aResult = reinterpret_cast(xpcom_obj); +#ifdef DEBUG_JAVAXPCOM + JavaXPCOMInstance* inst = static_cast(*aResult); + nsIID* iid; + inst->InterfaceInfo()->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + LOG(("< GetXPCOMInstFromProxy (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + aJavaObject), + (PRUint32) inst->GetInstance(), iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); +#endif + return NS_OK; +} + +/** + * org.mozilla.xpcom.internal.XPCOMJavaProxy.finalizeProxy + */ +extern "C" NS_EXPORT void JNICALL +JAVAPROXY_NATIVE(finalizeProxy) (JNIEnv *env, jclass that, jobject aJavaProxy) +{ +#ifdef DEBUG_JAVAXPCOM + PRUint32 xpcom_addr = 0; +#endif + + // Due to Java's garbage collection, this finalize statement may get called + // after FreeJavaGlobals(). So check to make sure that everything is still + // initialized. + if (gJavaXPCOMLock) { + nsAutoLock lock(gJavaXPCOMLock); + + // If may be possible for the lock to be acquired here when FreeGlobals is + // in the middle of running. If so, then this thread will sleep until + // FreeGlobals releases its lock. At that point, we resume this thread + // here, but JavaXPCOM may no longer be initialized. So we need to check + // that everything is legit after acquiring the lock. + if (gJavaXPCOMInitialized) { + // Get native XPCOM instance + void* xpcom_obj; + nsresult rv = GetXPCOMInstFromProxy(env, aJavaProxy, &xpcom_obj); + if (NS_SUCCEEDED(rv)) { + JavaXPCOMInstance* inst = static_cast(xpcom_obj); +#ifdef DEBUG_JAVAXPCOM + xpcom_addr = reinterpret_cast(inst->GetInstance()); +#endif + nsIID* iid; + rv = inst->InterfaceInfo()->GetInterfaceIID(&iid); + if (NS_SUCCEEDED(rv)) { + rv = gNativeToJavaProxyMap->Remove(env, inst->GetInstance(), *iid); + nsMemory::Free(iid); + } + NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to RemoveJavaProxy"); + // Release gJavaXPCOMLock before deleting inst (see bug 340022) + lock.unlock(); + delete inst; + } + } + } + +#ifdef DEBUG_JAVAXPCOM + LOG(("- Finalize (Java=%08x | XPCOM=%08x)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + aJavaProxy), + xpcom_addr)); +#endif +} + +/** + * org.mozilla.xpcom.XPCOMJavaProxy.isSameXPCOMObject + */ +extern "C" NS_EXPORT jboolean JNICALL +JAVAPROXY_NATIVE(isSameXPCOMObject) (JNIEnv *env, jclass that, + jobject aProxy1, jobject aProxy2) +{ + void* xpcom_obj1; + nsresult rv = GetXPCOMInstFromProxy(env, aProxy1, &xpcom_obj1); + if (NS_SUCCEEDED(rv)) { + void* xpcom_obj2; + rv = GetXPCOMInstFromProxy(env, aProxy2, &xpcom_obj2); + if (NS_SUCCEEDED(rv)) { + JavaXPCOMInstance* inst1 = static_cast(xpcom_obj1); + JavaXPCOMInstance* inst2 = static_cast(xpcom_obj2); + if (inst1->GetInstance() == inst2->GetInstance()) { + return JNI_TRUE; + } + } + } + return JNI_FALSE; +} + +/** + * org.mozilla.xpcom.ProfileLock.release + */ +extern "C" NS_EXPORT void JNICALL +LOCKPROXY_NATIVE(release) (JNIEnv *env, jclass that, jlong aLockObject) +{ + // Need to release object on the main thread. + nsresult rv = NS_ERROR_FAILURE; +#ifdef VBOX + rv = NS_ProxyRelease(do_GetMainThreadQueue().get(), reinterpret_cast(aLockObject)); +#else + nsCOMPtr thread = do_GetMainThread(); + if (thread) { + rv = NS_ProxyRelease(thread, reinterpret_cast(aLockObject)); + } +#endif + NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to release using NS_ProxyRelease"); +} diff --git a/src/libs/xpcom18a4/java/src/nsJavaWrapper.h b/src/libs/xpcom18a4/java/src/nsJavaWrapper.h new file mode 100644 index 00000000..c441a41c --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaWrapper.h @@ -0,0 +1,75 @@ +/* ***** 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 ***** */ + +#ifndef _nsJavaWrapper_h_ +#define _nsJavaWrapper_h_ + +#include "jni.h" +#include "nsISupports.h" + + +/** + * Finds the associated Java wraper for the given XPCOM object and IID. If no + * such Java wrapper exists, then a new one is created. + * + * @param env Java environment pointer + * @param aXPCOMObject XPCOM object for which to find/create Java wrapper + * @param aIID desired interface IID for Java wrapper + * @param aObjectLoader Java wrapper whose class loader we use for finding + * classes; can be null + * @param aResult on success, holds reference to Java wrapper + * + * @return NS_OK if succeeded; all other return values are error codes. + */ +nsresult GetNewOrUsedJavaWrapper(JNIEnv* env, nsISupports* aXPCOMObject, + const nsIID& aIID, jobject aObjectLoader, + jobject* aResult); + +/** + * Returns the XPCOM object for which the given Java proxy was created. + * + * @param env pointer to Java context + * @param aJavaObject a Java proxy created by CreateJavaProxy() + * @param aResult on exit, holds pointer to XPCOM instance + * + * @return NS_OK if the XPCOM object was successfully retrieved; + * any other value denotes an error condition. + */ +nsresult GetXPCOMInstFromProxy(JNIEnv* env, jobject aJavaObject, + void** aResult); + +#endif // _nsJavaWrapper_h_ diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.cpp b/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.cpp new file mode 100644 index 00000000..f91fdd83 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.cpp @@ -0,0 +1,1084 @@ +/* ***** 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 ***** */ + + +#include "nsJavaXPCOMBindingUtils.h" +#include "nsJavaXPTCStub.h" +#include "nsJavaWrapper.h" +#include "jni.h" +#include "nsIInterfaceInfoManager.h" +#include "nsThreadUtils.h" +#include "nsProxyRelease.h" +#ifdef VBOX +#ifndef NS_INT32_TO_PTR +#define NS_INT32_TO_PTR(x) ((void *)((char *)0 + (x))) +#endif +#endif + + +/* Java JNI globals */ + +JavaVM* gCachedJVM = nsnull; + +jclass systemClass = nsnull; +jclass booleanClass = nsnull; +jclass charClass = nsnull; +jclass byteClass = nsnull; +jclass shortClass = nsnull; +jclass intClass = nsnull; +jclass longClass = nsnull; +jclass floatClass = nsnull; +jclass doubleClass = nsnull; +jclass stringClass = nsnull; +jclass nsISupportsClass = nsnull; +jclass xpcomExceptionClass = nsnull; +jclass xpcomJavaProxyClass = nsnull; +jclass weakReferenceClass = nsnull; +jclass javaXPCOMUtilsClass = nsnull; + +jmethodID hashCodeMID = nsnull; +jmethodID booleanValueMID = nsnull; +jmethodID booleanInitMID = nsnull; +jmethodID charValueMID = nsnull; +jmethodID charInitMID = nsnull; +jmethodID byteValueMID = nsnull; +jmethodID byteInitMID = nsnull; +jmethodID shortValueMID = nsnull; +jmethodID shortInitMID = nsnull; +jmethodID intValueMID = nsnull; +jmethodID intInitMID = nsnull; +jmethodID longValueMID = nsnull; +jmethodID longInitMID = nsnull; +jmethodID floatValueMID = nsnull; +jmethodID floatInitMID = nsnull; +jmethodID doubleValueMID = nsnull; +jmethodID doubleInitMID = nsnull; +jmethodID createProxyMID = nsnull; +jmethodID isXPCOMJavaProxyMID = nsnull; +jmethodID getNativeXPCOMInstMID = nsnull; +jmethodID weakReferenceConstructorMID = nsnull; +jmethodID getReferentMID = nsnull; +jmethodID clearReferentMID = nsnull; +jmethodID findClassInLoaderMID = nsnull; + +#ifdef DEBUG_JAVAXPCOM +jmethodID getNameMID = nsnull; +jmethodID proxyToStringMID = nsnull; +#endif + +NativeToJavaProxyMap* gNativeToJavaProxyMap = nsnull; +JavaToXPTCStubMap* gJavaToXPTCStubMap = nsnull; + +PRBool gJavaXPCOMInitialized = PR_FALSE; +PRLock* gJavaXPCOMLock = nsnull; + +static const char* kJavaKeywords[] = { + "abstract", "default" , "if" , "private" , "throw" , + "boolean" , "do" , "implements", "protected" , "throws" , + "break" , "double" , "import", "public" , "transient" , + "byte" , "else" , "instanceof", "return" , "try" , + "case" , "extends" , "int" , "short" , "void" , + "catch" , "final" , "interface" , "static" , "volatile" , + "char" , "finally" , "long" , "super" , "while" , + "class" , "float" , "native" , "switch" , + "const" , "for" , "new" , "synchronized", + "continue", "goto" , "package" , "this" , + /* added in Java 1.2 */ + "strictfp", + /* added in Java 1.4 */ + "assert" , + /* added in Java 5.0 */ + "enum" , + /* Java constants */ + "true" , "false" , "null" , + /* java.lang.Object methods * + * - don't worry about "toString", since it does the same thing * + * as Object's "toString" */ + "clone" , "equals" , "finalize" , "getClass" , "hashCode" , + "notify" , "notifyAll", /*"toString" ,*/ "wait" +}; + +nsTHashtable* gJavaKeywords = nsnull; + + +/****************************** + * InitializeJavaGlobals + ******************************/ +PRBool +InitializeJavaGlobals(JNIEnv *env) +{ + if (gJavaXPCOMInitialized) + return PR_TRUE; + + // Save pointer to JavaVM, which is valid across threads. + jint rc = env->GetJavaVM(&gCachedJVM); + if (rc != 0) { + NS_WARNING("Failed to get JavaVM"); + goto init_error; + } + + jclass clazz; + if (!(clazz = env->FindClass("java/lang/System")) || + !(systemClass = (jclass) env->NewGlobalRef(clazz)) || + !(hashCodeMID = env->GetStaticMethodID(clazz, "identityHashCode", + "(Ljava/lang/Object;)I"))) + { + NS_WARNING("Problem creating java.lang.System globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Boolean")) || + !(booleanClass = (jclass) env->NewGlobalRef(clazz)) || + !(booleanValueMID = env->GetMethodID(clazz, "booleanValue", "()Z")) || + !(booleanInitMID = env->GetMethodID(clazz, "", "(Z)V"))) + { + NS_WARNING("Problem creating java.lang.Boolean globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Character")) || + !(charClass = (jclass) env->NewGlobalRef(clazz)) || + !(charValueMID = env->GetMethodID(clazz, "charValue", "()C")) || + !(charInitMID = env->GetMethodID(clazz, "", "(C)V"))) + { + NS_WARNING("Problem creating java.lang.Character globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Byte")) || + !(byteClass = (jclass) env->NewGlobalRef(clazz)) || + !(byteValueMID = env->GetMethodID(clazz, "byteValue", "()B")) || + !(byteInitMID = env->GetMethodID(clazz, "", "(B)V"))) + { + NS_WARNING("Problem creating java.lang.Byte globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Short")) || + !(shortClass = (jclass) env->NewGlobalRef(clazz)) || + !(shortValueMID = env->GetMethodID(clazz, "shortValue", "()S")) || + !(shortInitMID = env->GetMethodID(clazz, "", "(S)V"))) + { + NS_WARNING("Problem creating java.lang.Short globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Integer")) || + !(intClass = (jclass) env->NewGlobalRef(clazz)) || + !(intValueMID = env->GetMethodID(clazz, "intValue", "()I")) || + !(intInitMID = env->GetMethodID(clazz, "", "(I)V"))) + { + NS_WARNING("Problem creating java.lang.Integer globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Long")) || + !(longClass = (jclass) env->NewGlobalRef(clazz)) || + !(longValueMID = env->GetMethodID(clazz, "longValue", "()J")) || + !(longInitMID = env->GetMethodID(clazz, "", "(J)V"))) + { + NS_WARNING("Problem creating java.lang.Long globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Float")) || + !(floatClass = (jclass) env->NewGlobalRef(clazz)) || + !(floatValueMID = env->GetMethodID(clazz, "floatValue", "()F")) || + !(floatInitMID = env->GetMethodID(clazz, "", "(F)V"))) + { + NS_WARNING("Problem creating java.lang.Float globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/Double")) || + !(doubleClass = (jclass) env->NewGlobalRef(clazz)) || + !(doubleValueMID = env->GetMethodID(clazz, "doubleValue", "()D")) || + !(doubleInitMID = env->GetMethodID(clazz, "", "(D)V"))) + { + NS_WARNING("Problem creating java.lang.Double globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/String")) || + !(stringClass = (jclass) env->NewGlobalRef(clazz))) + { + NS_WARNING("Problem creating java.lang.String globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("org/mozilla/interfaces/nsISupports")) || + !(nsISupportsClass = (jclass) env->NewGlobalRef(clazz))) + { + NS_WARNING("Problem creating org.mozilla.interfaces.nsISupports globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("org/mozilla/xpcom/XPCOMException")) || + !(xpcomExceptionClass = (jclass) env->NewGlobalRef(clazz))) + { + NS_WARNING("Problem creating org.mozilla.xpcom.XPCOMException globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("org/mozilla/xpcom/internal/XPCOMJavaProxy")) || + !(xpcomJavaProxyClass = (jclass) env->NewGlobalRef(clazz)) || + !(createProxyMID = env->GetStaticMethodID(clazz, "createProxy", + "(Ljava/lang/Class;J)Ljava/lang/Object;")) || + !(isXPCOMJavaProxyMID = env->GetStaticMethodID(clazz, "isXPCOMJavaProxy", + "(Ljava/lang/Object;)Z")) || + !(getNativeXPCOMInstMID = env->GetStaticMethodID(xpcomJavaProxyClass, + "getNativeXPCOMInstance", + "(Ljava/lang/Object;)J"))) + { + NS_WARNING("Problem creating org.mozilla.xpcom.internal.XPCOMJavaProxy globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("java/lang/ref/WeakReference")) || + !(weakReferenceClass = (jclass) env->NewGlobalRef(clazz)) || + !(weakReferenceConstructorMID = env->GetMethodID(weakReferenceClass, + "","(Ljava/lang/Object;)V")) || + !(getReferentMID = env->GetMethodID(weakReferenceClass, + "get", "()Ljava/lang/Object;")) || + !(clearReferentMID = env->GetMethodID(weakReferenceClass, + "clear", "()V"))) + { + NS_WARNING("Problem creating java.lang.ref.WeakReference globals"); + goto init_error; + } + + if (!(clazz = env->FindClass("org/mozilla/xpcom/internal/JavaXPCOMMethods")) || + !(javaXPCOMUtilsClass = (jclass) env->NewGlobalRef(clazz)) || + !(findClassInLoaderMID = env->GetStaticMethodID(clazz, + "findClassInLoader", + "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Class;"))) + { + NS_WARNING("Problem creating org.mozilla.xpcom.internal.JavaXPCOMMethods globals"); + goto init_error; + } + +#ifdef DEBUG_JAVAXPCOM + if (!(clazz = env->FindClass("java/lang/Class")) || + !(getNameMID = env->GetMethodID(clazz, "getName","()Ljava/lang/String;"))) + { + NS_WARNING("Problem creating java.lang.Class globals"); + goto init_error; + } + + if (!(proxyToStringMID = env->GetStaticMethodID(xpcomJavaProxyClass, + "proxyToString", + "(Ljava/lang/Object;)Ljava/lang/String;"))) + { + NS_WARNING("Problem creating proxyToString global"); + goto init_error; + } +#endif + + gNativeToJavaProxyMap = new NativeToJavaProxyMap(); + if (!gNativeToJavaProxyMap || NS_FAILED(gNativeToJavaProxyMap->Init())) { + NS_WARNING("Problem creating NativeToJavaProxyMap"); + goto init_error; + } + gJavaToXPTCStubMap = new JavaToXPTCStubMap(); + if (!gJavaToXPTCStubMap || NS_FAILED(gJavaToXPTCStubMap->Init())) { + NS_WARNING("Problem creating JavaToXPTCStubMap"); + goto init_error; + } + + { + nsresult rv = NS_OK; + PRUint32 size = NS_ARRAY_LENGTH(kJavaKeywords); + gJavaKeywords = new nsTHashtable(); + if (!gJavaKeywords || NS_FAILED(gJavaKeywords->Init(size))) { + NS_WARNING("Failed to init JavaKeywords HashSet"); + goto init_error; + } + for (PRUint32 i = 0; i < size && NS_SUCCEEDED(rv); i++) { + if (!gJavaKeywords->PutEntry(kJavaKeywords[i])) { + rv = NS_ERROR_OUT_OF_MEMORY; + } + } + if (NS_FAILED(rv)) { + NS_WARNING("Failed to populate JavaKeywords hash"); + goto init_error; + } + } + + gJavaXPCOMLock = PR_NewLock(); + gJavaXPCOMInitialized = PR_TRUE; + return PR_TRUE; + +init_error: + // If we encounter an error during initialization, then free any globals that + // were allocated, and return false. + FreeJavaGlobals(env); + return PR_FALSE; +} + +/************************* + * FreeJavaGlobals + *************************/ +void +FreeJavaGlobals(JNIEnv* env) +{ + PRLock* tempLock = nsnull; + if (gJavaXPCOMLock) { + PR_Lock(gJavaXPCOMLock); + + // null out global lock so no one else can use it + tempLock = gJavaXPCOMLock; + gJavaXPCOMLock = nsnull; + } + + gJavaXPCOMInitialized = PR_FALSE; + + // Free the mappings first, since that process depends on some of the Java + // globals that are freed later. + if (gNativeToJavaProxyMap) { + gNativeToJavaProxyMap->Destroy(env); + delete gNativeToJavaProxyMap; + gNativeToJavaProxyMap = nsnull; + } + if (gJavaToXPTCStubMap) { + gJavaToXPTCStubMap->Destroy(); + delete gJavaToXPTCStubMap; + gJavaToXPTCStubMap = nsnull; + } + + // Free remaining Java globals + if (systemClass) { + env->DeleteGlobalRef(systemClass); + systemClass = nsnull; + } + if (booleanClass) { + env->DeleteGlobalRef(booleanClass); + booleanClass = nsnull; + } + if (charClass) { + env->DeleteGlobalRef(charClass); + charClass = nsnull; + } + if (byteClass) { + env->DeleteGlobalRef(byteClass); + byteClass = nsnull; + } + if (shortClass) { + env->DeleteGlobalRef(shortClass); + shortClass = nsnull; + } + if (intClass) { + env->DeleteGlobalRef(intClass); + intClass = nsnull; + } + if (longClass) { + env->DeleteGlobalRef(longClass); + longClass = nsnull; + } + if (floatClass) { + env->DeleteGlobalRef(floatClass); + floatClass = nsnull; + } + if (doubleClass) { + env->DeleteGlobalRef(doubleClass); + doubleClass = nsnull; + } + if (stringClass) { + env->DeleteGlobalRef(stringClass); + stringClass = nsnull; + } + if (nsISupportsClass) { + env->DeleteGlobalRef(nsISupportsClass); + nsISupportsClass = nsnull; + } + if (xpcomExceptionClass) { + env->DeleteGlobalRef(xpcomExceptionClass); + xpcomExceptionClass = nsnull; + } + if (xpcomJavaProxyClass) { + env->DeleteGlobalRef(xpcomJavaProxyClass); + xpcomJavaProxyClass = nsnull; + } + if (weakReferenceClass) { + env->DeleteGlobalRef(weakReferenceClass); + weakReferenceClass = nsnull; + } + + if (gJavaKeywords) { + delete gJavaKeywords; + gJavaKeywords = nsnull; + } + + if (tempLock) { + PR_Unlock(tempLock); + PR_DestroyLock(tempLock); + } +} + + +/************************************** + * Java<->XPCOM object mappings + **************************************/ + +// NativeToJavaProxyMap: The common case is that each XPCOM object will have +// one Java proxy. But there are instances where there will be multiple Java +// proxies for a given XPCOM object, each representing a different interface. +// So we optimize the common case by using a hash table. Then, if there are +// multiple Java proxies, we cycle through the linked list, comparing IIDs. + +nsresult +NativeToJavaProxyMap::Init() +{ + mHashTable = PL_NewDHashTable(PL_DHashGetStubOps(), nsnull, + sizeof(Entry), 16); + if (!mHashTable) + return NS_ERROR_OUT_OF_MEMORY; + return NS_OK; +} + +PLDHashOperator +DestroyJavaProxyMappingEnum(PLDHashTable* aTable, PLDHashEntryHdr* aHeader, + PRUint32 aNumber, void* aData) +{ + JNIEnv* env = static_cast(aData); + NativeToJavaProxyMap::Entry* entry = + static_cast(aHeader); + + // first, delete XPCOM instances from the Java proxies + nsresult rv; + NativeToJavaProxyMap::ProxyList* item = entry->list; + while(item != nsnull) { + void* xpcom_obj; + jobject javaObject = env->CallObjectMethod(item->javaObject, getReferentMID); + rv = GetXPCOMInstFromProxy(env, javaObject, &xpcom_obj); + NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to get XPCOM instance from Java proxy"); + + if (NS_SUCCEEDED(rv)) { + JavaXPCOMInstance* inst = static_cast(xpcom_obj); +#ifdef DEBUG_JAVAXPCOM + char* iid_str = item->iid.ToString(); + LOG(("- NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + javaObject), + (PRUint32) entry, iid_str)); + PR_Free(iid_str); +#endif + delete inst; // releases native XPCOM object + } + + NativeToJavaProxyMap::ProxyList* next = item->next; + env->CallVoidMethod(item->javaObject, clearReferentMID); + env->DeleteGlobalRef(item->javaObject); + delete item; + item = next; + } + + return PL_DHASH_REMOVE; +} + +nsresult +NativeToJavaProxyMap::Destroy(JNIEnv* env) +{ + // This is only called from FreeGlobals(), which already holds the lock. + // nsAutoLock lock(gJavaXPCOMLock); + + PL_DHashTableEnumerate(mHashTable, DestroyJavaProxyMappingEnum, env); + PL_DHashTableDestroy(mHashTable); + mHashTable = nsnull; + + return NS_OK; +} + +nsresult +NativeToJavaProxyMap::Add(JNIEnv* env, nsISupports* aXPCOMObject, + const nsIID& aIID, jobject aProxy) +{ + nsAutoLock lock(gJavaXPCOMLock); + + Entry* e = static_cast(PL_DHashTableOperate(mHashTable, + aXPCOMObject, + PL_DHASH_ADD)); + if (!e) + return NS_ERROR_FAILURE; + + jobject ref = nsnull; + jobject weakRefObj = env->NewObject(weakReferenceClass, + weakReferenceConstructorMID, aProxy); + if (weakRefObj) + ref = env->NewGlobalRef(weakRefObj); + if (!ref) + return NS_ERROR_OUT_OF_MEMORY; + + // Add Java proxy weak reference ref to start of list + ProxyList* item = new ProxyList(ref, aIID, e->list); + e->key = aXPCOMObject; + e->list = item; + +#ifdef DEBUG_JAVAXPCOM + char* iid_str = aIID.ToString(); + LOG(("+ NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, aProxy), + (PRUint32) aXPCOMObject, iid_str)); + PR_Free(iid_str); +#endif + return NS_OK; +} + +nsresult +NativeToJavaProxyMap::Find(JNIEnv* env, nsISupports* aNativeObject, + const nsIID& aIID, jobject* aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_FAILURE; + + nsAutoLock lock(gJavaXPCOMLock); + + *aResult = nsnull; + Entry* e = static_cast(PL_DHashTableOperate(mHashTable, + aNativeObject, + PL_DHASH_LOOKUP)); + + if (PL_DHASH_ENTRY_IS_FREE(e)) + return NS_OK; + + ProxyList* item = e->list; + while (item != nsnull && *aResult == nsnull) { + if (item->iid.Equals(aIID)) { + jobject referentObj = env->CallObjectMethod(item->javaObject, + getReferentMID); + if (!env->IsSameObject(referentObj, NULL)) { + *aResult = referentObj; +#ifdef DEBUG_JAVAXPCOM + char* iid_str = aIID.ToString(); + LOG(("< NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + *aResult), + (PRUint32) aNativeObject, iid_str)); + PR_Free(iid_str); +#endif + } + } + item = item->next; + } + + return NS_OK; +} + +nsresult +NativeToJavaProxyMap::Remove(JNIEnv* env, nsISupports* aNativeObject, + const nsIID& aIID) +{ + // This is only called from finalizeProxy(), which already holds the lock. + // nsAutoLock lock(gJavaXPCOMLock); + + Entry* e = static_cast(PL_DHashTableOperate(mHashTable, + aNativeObject, + PL_DHASH_LOOKUP)); + + if (PL_DHASH_ENTRY_IS_FREE(e)) { + NS_WARNING("XPCOM object not found in hash table"); + return NS_ERROR_FAILURE; + } + + ProxyList* item = e->list; + ProxyList* last = e->list; + while (item != nsnull) { + if (item->iid.Equals(aIID)) { +#ifdef DEBUG_JAVAXPCOM + char* iid_str = aIID.ToString(); + LOG(("- NativeToJavaProxyMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) env->CallStaticIntMethod(systemClass, hashCodeMID, + item->javaObject), + (PRUint32) aNativeObject, iid_str)); + PR_Free(iid_str); +#endif + + env->CallVoidMethod(item->javaObject, clearReferentMID); + env->DeleteGlobalRef(item->javaObject); + if (item == e->list) { + e->list = item->next; + if (e->list == nsnull) + PL_DHashTableOperate(mHashTable, aNativeObject, PL_DHASH_REMOVE); + } else { + last->next = item->next; + } + + delete item; + return NS_OK; + } + + last = item; + item = item->next; + } + + NS_WARNING("Java proxy matching given IID not found"); + return NS_ERROR_FAILURE; +} + +nsresult +JavaToXPTCStubMap::Init() +{ + mHashTable = PL_NewDHashTable(PL_DHashGetStubOps(), nsnull, + sizeof(Entry), 16); + if (!mHashTable) + return NS_ERROR_OUT_OF_MEMORY; + return NS_OK; +} + + +PLDHashOperator +DestroyXPTCMappingEnum(PLDHashTable* aTable, PLDHashEntryHdr* aHeader, + PRUint32 aNumber, void* aData) +{ + JavaToXPTCStubMap::Entry* entry = + static_cast(aHeader); + + // The XPTC stub will be released by the XPCOM side, if it hasn't been + // already. We just need to delete the Java global ref held by the XPTC stub, + // so the Java garbage collector can handle the Java object when necessary. + entry->xptcstub->DeleteStrongRef(); + + return PL_DHASH_REMOVE; +} + +nsresult +JavaToXPTCStubMap::Destroy() +{ + // This is only called from FreeGlobals(), which already holds the lock. + // nsAutoLock lock(gJavaXPCOMLock); + + PL_DHashTableEnumerate(mHashTable, DestroyXPTCMappingEnum, nsnull); + PL_DHashTableDestroy(mHashTable); + mHashTable = nsnull; + + return NS_OK; +} + +nsresult +JavaToXPTCStubMap::Add(jint aJavaObjectHashCode, nsJavaXPTCStub* aProxy) +{ + nsAutoLock lock(gJavaXPCOMLock); + + Entry* e = static_cast + (PL_DHashTableOperate(mHashTable, + NS_INT32_TO_PTR(aJavaObjectHashCode), + PL_DHASH_ADD)); + if (!e) + return NS_ERROR_FAILURE; + + NS_ASSERTION(e->key == nsnull, + "XPTCStub for given Java object already exists in hash table"); + e->key = aJavaObjectHashCode; + e->xptcstub = aProxy; + +#ifdef DEBUG_JAVAXPCOM + nsIInterfaceInfo* iface_info; + aProxy->GetInterfaceInfo(&iface_info); + nsIID* iid; + iface_info->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + LOG(("+ JavaToXPTCStubMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) aJavaObjectHashCode, (PRUint32) aProxy, iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); + NS_RELEASE(iface_info); +#endif + return NS_OK; +} + +nsresult +JavaToXPTCStubMap::Find(jint aJavaObjectHashCode, const nsIID& aIID, + nsJavaXPTCStub** aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_FAILURE; + + nsAutoLock lock(gJavaXPCOMLock); + + *aResult = nsnull; + Entry* e = static_cast + (PL_DHashTableOperate(mHashTable, + NS_INT32_TO_PTR(aJavaObjectHashCode), + PL_DHASH_LOOKUP)); + + if (PL_DHASH_ENTRY_IS_FREE(e)) + return NS_OK; + + nsresult rv = e->xptcstub->QueryInterface(aIID, (void**) aResult); + +#ifdef DEBUG_JAVAXPCOM + if (NS_SUCCEEDED(rv)) { + char* iid_str = aIID.ToString(); + LOG(("< JavaToXPTCStubMap (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) aJavaObjectHashCode, (PRUint32) *aResult, iid_str)); + PR_Free(iid_str); + } +#endif + + // NS_NOINTERFACE is not an error condition + if (rv == NS_NOINTERFACE) + rv = NS_OK; + return rv; +} + +nsresult +JavaToXPTCStubMap::Remove(jint aJavaObjectHashCode) +{ + PL_DHashTableOperate(mHashTable, NS_INT32_TO_PTR(aJavaObjectHashCode), + PL_DHASH_REMOVE); + +#ifdef DEBUG_JAVAXPCOM + LOG(("- JavaToXPTCStubMap (Java=%08x)\n", (PRUint32) aJavaObjectHashCode)); +#endif + + return NS_OK; +} + + +/********************************************************** + * JavaXPCOMInstance + *********************************************************/ +JavaXPCOMInstance::JavaXPCOMInstance(nsISupports* aInstance, + nsIInterfaceInfo* aIInfo) + : mInstance(aInstance) + , mIInfo(aIInfo) +{ + NS_ADDREF(mInstance); + NS_ADDREF(mIInfo); +} + +JavaXPCOMInstance::~JavaXPCOMInstance() +{ + nsresult rv = NS_OK; + +#ifdef VBOX +# if 0 + nsCOMPtr eq = do_GetMainThreadQueue(); + rv = NS_ProxyRelease(eq.get(), mInstance); + rv |= NS_ProxyRelease(eq.get(), mIInfo); +# else + // The above code crashes in nsTraceRefcntImpl::LogAddCOMPtr() (@bugref 7620) + NS_RELEASE(mInstance); + NS_RELEASE(mIInfo); + rv = NS_OK; +# endif +#else + // Need to release these objects on the main thread. + nsCOMPtr thread = do_GetMainThread(); + if (thread) { + rv = NS_ProxyRelease(thread, mInstance); + rv |= NS_ProxyRelease(thread, mIInfo); + } +#endif + NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to release using NS_ProxyRelease"); +} + + +/******************************* + * Helper functions + *******************************/ + +nsresult +NativeInterfaceToJavaObject(JNIEnv* env, nsISupports* aXPCOMObject, + const nsIID& aIID, jobject aObjectLoader, + jobject* aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_NULL_POINTER; + + // If the object is an nsJavaXPTCStub, then get the Java object directly + nsJavaXPTCStub* stub = nsnull; + aXPCOMObject->QueryInterface(NS_GET_IID(nsJavaXPTCStub), (void**) &stub); + if (stub) { + *aResult = stub->GetJavaObject(); + NS_ASSERTION(*aResult != nsnull, "nsJavaXPTCStub w/o matching Java object"); + NS_RELEASE(stub); + return NS_OK; + } + + // ... else, get a Java wrapper for the native object + return GetNewOrUsedJavaWrapper(env, aXPCOMObject, aIID, aObjectLoader, + aResult); +} + +nsresult +JavaObjectToNativeInterface(JNIEnv* env, jobject aJavaObject, const nsIID& aIID, + void** aResult) +{ + NS_PRECONDITION(aResult != nsnull, "null ptr"); + if (!aResult) + return NS_ERROR_NULL_POINTER; + + nsresult rv; + *aResult = nsnull; + + // If the given Java object is one of our Java proxies, then query the + // associated XPCOM object directly from the proxy. + jboolean isProxy = env->CallStaticBooleanMethod(xpcomJavaProxyClass, + isXPCOMJavaProxyMID, + aJavaObject); + if (env->ExceptionCheck()) + return NS_ERROR_FAILURE; + + if (isProxy) { + void* inst; + rv = GetXPCOMInstFromProxy(env, aJavaObject, &inst); + NS_ENSURE_SUCCESS(rv, rv); + + nsISupports* rootObject = + static_cast(inst)->GetInstance(); + rv = rootObject->QueryInterface(aIID, aResult); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; + } + + // ... else, we get an nsJavaXPTCStub + return nsJavaXPTCStub::GetNewOrUsed(env, aJavaObject, aIID, aResult); +} + +nsresult +GetIIDForMethodParam(nsIInterfaceInfo *iinfo, + const XPTMethodDescriptor *methodInfo, + const nsXPTParamInfo ¶mInfo, PRUint8 paramType, + PRUint16 methodIndex, nsXPTCMiniVariant *dispatchParams, + PRBool isFullVariantArray, nsID &result) +{ + nsresult rv; + + switch (paramType) + { + case nsXPTType::T_INTERFACE: + rv = iinfo->GetIIDForParamNoAlloc(methodIndex, ¶mInfo, &result); + break; + + case nsXPTType::T_INTERFACE_IS: + { + PRUint8 argnum; + rv = iinfo->GetInterfaceIsArgNumberForParam(methodIndex, ¶mInfo, + &argnum); + if (NS_FAILED(rv)) + break; + + const nsXPTParamInfo& arg_param = methodInfo->params[argnum]; + const nsXPTType& arg_type = arg_param.GetType(); + + // The xpidl compiler ensures this. We reaffirm it for safety. + if (!arg_type.IsPointer() || arg_type.TagPart() != nsXPTType::T_IID) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + nsID *p = nsnull; + if (isFullVariantArray) { + p = (nsID *) ((nsXPTCVariant*) dispatchParams)[argnum].val.p; + } else { + p = (nsID *) dispatchParams[argnum].val.p; + } + if (!p) + return NS_ERROR_UNEXPECTED; + + result = *p; + break; + } + + default: + rv = NS_ERROR_UNEXPECTED; + } + return rv; +} + + +/******************************* + * JNI helper functions + *******************************/ + +JNIEnv* +GetJNIEnv() +{ + JNIEnv* env = nsnull; + jint rc = gCachedJVM->GetEnv((void**) &env, JNI_VERSION_1_2); +#ifdef VBOX + if (env == nsnull) + { + rc = gCachedJVM->AttachCurrentThreadAsDaemon((void**)&env, nsnull); + printf("attaching\n"); + } +#endif + NS_ASSERTION(rc == JNI_OK && env != nsnull, + "Current thread not attached to given JVM instance"); + return env; +} + +void +ThrowException(JNIEnv* env, const nsresult aErrorCode, const char* aMessage) +{ + // Only throw this exception if one hasn't already been thrown, so we don't + // mask a previous exception/error. + if (env->ExceptionCheck()) + return; + + // If the error code we get is for an Out Of Memory error, try to throw an + // OutOfMemoryError. The JVM may have enough memory to create this error. + if (aErrorCode == NS_ERROR_OUT_OF_MEMORY) { + jclass clazz = env->FindClass("java/lang/OutOfMemoryError"); + if (clazz) { + env->ThrowNew(clazz, aMessage); + } + env->DeleteLocalRef(clazz); + return; + } + + // If the error was not handled above, then create an XPCOMException with the + // given error code and message. + + // Create parameters and method signature. Max of 2 params. The error code + // comes before the message string. + PRInt64 errorCode = aErrorCode ? aErrorCode : NS_ERROR_FAILURE; + nsCAutoString methodSig("(J"); + jstring message = nsnull; + if (aMessage) { + message = env->NewStringUTF(aMessage); + if (!message) { + return; + } + methodSig.AppendLiteral("Ljava/lang/String;"); + } + methodSig.AppendLiteral(")V"); + + // In some instances (such as in shutdownXPCOM() and termEmbedding()), we + // will need to throw an exception when JavaXPCOM has already been + // terminated. In such a case, 'xpcomExceptionClass' will be null. So we + // reset it temporarily in order to throw the appropriate exception. + if (xpcomExceptionClass == nsnull) { + xpcomExceptionClass = env->FindClass("org/mozilla/xpcom/XPCOMException"); + if (!xpcomExceptionClass) { + return; + } + } + + // create exception object + jthrowable throwObj = nsnull; + jmethodID mid = env->GetMethodID(xpcomExceptionClass, "", + methodSig.get()); + if (mid) { + throwObj = (jthrowable) env->NewObject(xpcomExceptionClass, mid, errorCode, + message); + } + NS_ASSERTION(throwObj, "Failed to create XPCOMException object"); + + // throw exception + if (throwObj) { + env->Throw(throwObj); + } +} + +nsAString* +jstring_to_nsAString(JNIEnv* env, jstring aString) +{ + const PRUnichar* buf = nsnull; + if (aString) { + buf = env->GetStringChars(aString, nsnull); + if (!buf) + return nsnull; // exception already thrown + } + + nsString* str = new nsString(buf); + + if (aString) { + env->ReleaseStringChars(aString, buf); + } else { + str->SetIsVoid(PR_TRUE); + } + + // returns string, or nsnull if 'new' failed + return str; +} + +nsACString* +jstring_to_nsACString(JNIEnv* env, jstring aString) +{ + const char* buf = nsnull; + if (aString) { + buf = env->GetStringUTFChars(aString, nsnull); + if (!buf) + return nsnull; // exception already thrown + } + + nsCString* str = new nsCString(buf); + + if (aString) { + env->ReleaseStringUTFChars(aString, buf); + } else { + str->SetIsVoid(PR_TRUE); + } + + // returns string, or nsnull if 'new' failed + return str; +} + +nsresult +File_to_nsILocalFile(JNIEnv* env, jobject aFile, nsILocalFile** aLocalFile) +{ + nsresult rv = NS_ERROR_FAILURE; + jstring pathName = nsnull; + jclass clazz = env->FindClass("java/io/File"); + if (clazz) { + jmethodID pathMID = env->GetMethodID(clazz, "getCanonicalPath", + "()Ljava/lang/String;"); + if (pathMID) { + pathName = (jstring) env->CallObjectMethod(aFile, pathMID); + if (pathName != nsnull && !env->ExceptionCheck()) + rv = NS_OK; + } + } + + if (NS_SUCCEEDED(rv)) { + nsAString* path = jstring_to_nsAString(env, pathName); + if (!path) + rv = NS_ERROR_OUT_OF_MEMORY; + + if (NS_SUCCEEDED(rv)) { + rv = NS_NewLocalFile(*path, false, aLocalFile); + delete path; + } + } + + return rv; +} diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.h b/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.h new file mode 100644 index 00000000..894a8cb8 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPCOMBindingUtils.h @@ -0,0 +1,392 @@ +/* ***** 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 ***** */ + +#ifndef _nsJavaXPCOMBindingUtils_h_ +#define _nsJavaXPCOMBindingUtils_h_ + +#include "jni.h" +#include "xptcall.h" +#include "nsCOMPtr.h" +#include "nsString.h" +#include "pldhash.h" +#include "nsJavaXPTCStub.h" +#include "nsAutoLock.h" +#include "nsTHashtable.h" +#include "nsHashKeys.h" +#include "nsILocalFile.h" + +//#define DEBUG_JAVAXPCOM +//#define DEBUG_JAVAXPCOM_REFCNT + +#ifdef DEBUG_JAVAXPCOM +#define LOG(x) printf x +#else +#define LOG(x) /* nothing */ +#endif + + +/********************* + * Java JNI globals + *********************/ + +extern jclass systemClass; +extern jclass booleanClass; +extern jclass charClass; +extern jclass byteClass; +extern jclass shortClass; +extern jclass intClass; +extern jclass longClass; +extern jclass floatClass; +extern jclass doubleClass; +extern jclass stringClass; +extern jclass nsISupportsClass; +extern jclass xpcomExceptionClass; +extern jclass xpcomJavaProxyClass; +extern jclass weakReferenceClass; +extern jclass javaXPCOMUtilsClass; + +extern jmethodID hashCodeMID; +extern jmethodID booleanValueMID; +extern jmethodID booleanInitMID; +extern jmethodID charValueMID; +extern jmethodID charInitMID; +extern jmethodID byteValueMID; +extern jmethodID byteInitMID; +extern jmethodID shortValueMID; +extern jmethodID shortInitMID; +extern jmethodID intValueMID; +extern jmethodID intInitMID; +extern jmethodID longValueMID; +extern jmethodID longInitMID; +extern jmethodID floatValueMID; +extern jmethodID floatInitMID; +extern jmethodID doubleValueMID; +extern jmethodID doubleInitMID; +extern jmethodID createProxyMID; +extern jmethodID isXPCOMJavaProxyMID; +extern jmethodID getNativeXPCOMInstMID; +extern jmethodID weakReferenceConstructorMID; +extern jmethodID getReferentMID; +extern jmethodID clearReferentMID; +extern jmethodID findClassInLoaderMID; + +#ifdef DEBUG_JAVAXPCOM +extern jmethodID getNameMID; +extern jmethodID proxyToStringMID; +#endif + +class NativeToJavaProxyMap; +extern NativeToJavaProxyMap* gNativeToJavaProxyMap; +class JavaToXPTCStubMap; +extern JavaToXPTCStubMap* gJavaToXPTCStubMap; + +extern nsTHashtable* gJavaKeywords; + +// The Java garbage collector runs in a separate thread. Since it calls the +// finalizeProxy() function in nsJavaWrapper.cpp, we need to make sure that +// all the structures touched by finalizeProxy() are multithread aware. +extern PRLock* gJavaXPCOMLock; + +extern PRBool gJavaXPCOMInitialized; + +/** + * Initialize global structures used by JavaXPCOM. + * @param env Java environment pointer + * @return PR_TRUE if JavaXPCOM is initialized; PR_FALSE if an error occurred + */ +PRBool InitializeJavaGlobals(JNIEnv *env); + +/** + * Frees global structures that were allocated by InitializeJavaGlobals(). + * @param env Java environment pointer + */ +void FreeJavaGlobals(JNIEnv* env); + + +/************************* + * JavaXPCOMInstance + *************************/ + +class JavaXPCOMInstance +{ +public: + JavaXPCOMInstance(nsISupports* aInstance, nsIInterfaceInfo* aIInfo); + ~JavaXPCOMInstance(); + + nsISupports* GetInstance() { return mInstance; } + nsIInterfaceInfo* InterfaceInfo() { return mIInfo; } + +private: + nsISupports* mInstance; + nsIInterfaceInfo* mIInfo; +}; + + +/************************************** + * Java<->XPCOM object mappings + **************************************/ + +/** + * Maps native XPCOM objects to their associated Java proxy object. + */ +class NativeToJavaProxyMap +{ + friend PLDHashOperator DestroyJavaProxyMappingEnum(PLDHashTable* aTable, + PLDHashEntryHdr* aHeader, + PRUint32 aNumber, + void* aData); + +protected: + struct ProxyList + { + ProxyList(const jobject aRef, const nsIID& aIID, ProxyList* aList) + : javaObject(aRef) + , iid(aIID) + , next(aList) + { } + + const jobject javaObject; + const nsIID iid; + ProxyList* next; + }; + + struct Entry : public PLDHashEntryHdr + { + nsISupports* key; + ProxyList* list; + }; + +public: + NativeToJavaProxyMap() + : mHashTable(nsnull) + { } + + ~NativeToJavaProxyMap() + { + NS_ASSERTION(mHashTable == nsnull, + "MUST call Destroy() before deleting object"); + } + + nsresult Init(); + + nsresult Destroy(JNIEnv* env); + + nsresult Add(JNIEnv* env, nsISupports* aXPCOMObject, const nsIID& aIID, + jobject aProxy); + + nsresult Find(JNIEnv* env, nsISupports* aNativeObject, const nsIID& aIID, + jobject* aResult); + + nsresult Remove(JNIEnv* env, nsISupports* aNativeObject, const nsIID& aIID); + +protected: + PLDHashTable* mHashTable; +}; + +/** + * Maps Java objects to their associated nsJavaXPTCStub. + */ +class JavaToXPTCStubMap +{ + friend PLDHashOperator DestroyXPTCMappingEnum(PLDHashTable* aTable, + PLDHashEntryHdr* aHeader, + PRUint32 aNumber, void* aData); + +protected: + struct Entry : public PLDHashEntryHdr + { + jint key; + nsJavaXPTCStub* xptcstub; + }; + +public: + JavaToXPTCStubMap() + : mHashTable(nsnull) + { } + + ~JavaToXPTCStubMap() + { + NS_ASSERTION(mHashTable == nsnull, + "MUST call Destroy() before deleting object"); + } + + nsresult Init(); + + nsresult Destroy(); + + nsresult Add(jint aJavaObjectHashCode, nsJavaXPTCStub* aProxy); + + nsresult Find(jint aJavaObjectHashCode, const nsIID& aIID, + nsJavaXPTCStub** aResult); + + nsresult Remove(jint aJavaObjectHashCode); + +protected: + PLDHashTable* mHashTable; +}; + + +/******************************* + * Helper functions + *******************************/ + +/** + * Convert a native nsISupports to a Java object. + * + * @param env Java environment pointer + * @param aXPCOMObject XPCOM object for which to find/create Java object + * @param aIID desired interface IID for Java object + * @param aObjectLoader Java object whose class loader we use for finding + * classes; can be null + * @param aResult on success, holds reference to Java object + * + * @return NS_OK if succeeded; all other return values are error codes. + */ +nsresult NativeInterfaceToJavaObject(JNIEnv* env, nsISupports* aXPCOMObject, + const nsIID& aIID, jobject aObjectLoader, + jobject* aResult); + +/** + * Convert a Java object to a native nsISupports object. + * + * @param env Java environment pointer + * @param aJavaObject Java object for which to find/create XPCOM object + * @param aIID desired interface IID for XPCOM object + * @param aResult on success, holds AddRef'd reference to XPCOM object + * + * @return NS_OK if succeeded; all other return values are error codes. + */ +nsresult JavaObjectToNativeInterface(JNIEnv* env, jobject aJavaObject, + const nsIID& aIID, void** aResult); + +nsresult GetIIDForMethodParam(nsIInterfaceInfo *iinfo, + const XPTMethodDescriptor *methodInfo, + const nsXPTParamInfo ¶mInfo, + PRUint8 paramType, PRUint16 methodIndex, + nsXPTCMiniVariant *dispatchParams, + PRBool isFullVariantArray, + nsID &result); + +/** + * Returns the Class object associated with the class or interface with the + * given string name, using the class loader of the given object. + * + * @param env Java environment pointer + * @param aObjectLoader Java object whose class loader is used to load class + * @param aClassName fully qualified name of class to load + * + * @return java.lang.Class object of requested Class; NULL if the class + * wasn't found + * + * @see http://java.sun.com/j2se/1.3/docs/guide/jni/jni-12.html#classops + */ +inline jclass +FindClassInLoader(JNIEnv* env, jobject aObjectLoader, const char* aClassName) +{ + jclass clazz = nsnull; + jstring name = env->NewStringUTF(aClassName); + if (name) + clazz = (jclass) env->CallStaticObjectMethod(javaXPCOMUtilsClass, + findClassInLoaderMID, aObjectLoader, name); + +#ifdef DEBUG + if (!clazz) + fprintf(stderr, "WARNING: failed to find class [%s]\n", aClassName); +#endif + return clazz; +} + + +/******************************* + * JNI helper functions + *******************************/ + +/** + * Returns a pointer to the appropriate JNIEnv structure. This function is + * useful in callbacks or other functions that are not called directly from + * Java and therefore do not have the JNIEnv structure passed in. + * + * @return pointer to JNIEnv structure for current thread + */ +JNIEnv* GetJNIEnv(); + +/** + * Constructs and throws an exception. Some error codes (such as + * NS_ERROR_OUT_OF_MEMORY) are handled by the appropriate Java exception/error. + * Otherwise, an instance of XPCOMException is created with the given error + * code and message. + * + * @param env Java environment pointer + * @param aErrorCode The error code returned by an XPCOM/Gecko function. Pass + * zero for the default behaviour. + * @param aMessage A string that provides details for throwing this + * exception. Pass in nsnull for the default + * behaviour. + * + * @throws OutOfMemoryError if aErrorCode == NS_ERROR_OUT_OF_MEMORY + * XPCOMException for all other error codes + */ +void ThrowException(JNIEnv* env, const nsresult aErrorCode, + const char* aMessage); + +/** + * Helper functions for converting from java.lang.String to + * nsAString/nsACstring. Caller must delete nsAString/nsACString. + * + * @param env Java environment pointer + * @param aString Java string to convert + * + * @return nsAString/nsACString with same content as given Java string; + * a 'void' nsAString/nsACString object if aString is + * null; or nsnull if out of memory + */ +nsAString* jstring_to_nsAString(JNIEnv* env, jstring aString); +nsACString* jstring_to_nsACString(JNIEnv* env, jstring aString); + +/** + * Helper function for converting from java.io.File to nsILocalFile. + * + * @param env Java environment pointer + * @param aFile Java File to convert + * @param aLocalFile returns the converted nsILocalFile + * + * @return NS_OK for success; other values indicate error in conversion + */ +nsresult File_to_nsILocalFile(JNIEnv* env, jobject aFile, + nsILocalFile** aLocalFile); + +#endif // _nsJavaXPCOMBindingUtils_h_ diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPCOMGlue.cpp b/src/libs/xpcom18a4/java/src/nsJavaXPCOMGlue.cpp new file mode 100644 index 00000000..b0b6b72c --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPCOMGlue.cpp @@ -0,0 +1,535 @@ +/* ***** 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 ***** */ + +#include "jni.h" +#include "nsXPCOMPrivate.h" // for XPCOM_DLL defines. +#include "nsXPCOMGlue.h" +#include + + +#ifdef VBOX +#include +#include "nsDebug.h" +#endif + +#if defined(XP_WIN) || defined(XP_OS2) +#define JX_EXPORT JNIEXPORT +#else +#define JX_EXPORT JNIEXPORT NS_EXPORT +#endif + + +/*********************** + * JNI Load & Unload + ***********************/ + +extern "C" JX_EXPORT jint JNICALL +JNI_OnLoad(JavaVM* vm, void* reserved) +{ + // Let the JVM know that we are using JDK 1.2 JNI features. + return JNI_VERSION_1_2; +} + +extern "C" JX_EXPORT void JNICALL +JNI_OnUnload(JavaVM* vm, void* reserved) +{ +} + +/******************************** + * JavaXPCOM JNI interfaces + ********************************/ + +#define JXM_NATIVE(func) Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_##func + +enum { + kFunc_Initialize, + kFunc_InitEmbedding, + kFunc_TermEmbedding, + kFunc_LockProfileDirectory, + kFunc_NotifyProfile, + kFunc_InitXPCOM, + kFunc_ShutdownXPCOM, + kFunc_GetComponentManager, + kFunc_GetComponentRegistrar, + kFunc_GetServiceManager, + kFunc_NewLocalFile, + kFunc_CallXPCOMMethod, + kFunc_FinalizeProxy, + kFunc_IsSameXPCOMObject, + kFunc_ReleaseProfileLock, + kFunc_GetNativeHandleFromAWT, + kFunc_WrapJavaObject, + kFunc_WrapXPCOMObject +}; + +#define JX_NUM_FUNCS 18 + + +// Get path string from java.io.File object. +jstring +GetJavaFilePath(JNIEnv* env, jobject aFile) +{ + jclass clazz = env->FindClass("java/io/File"); + if (clazz) { + jmethodID pathMID = env->GetMethodID(clazz, "getCanonicalPath", + "()Ljava/lang/String;"); + if (pathMID) { + return (jstring) env->CallObjectMethod(aFile, pathMID); + } + } + + return nsnull; +} +#ifdef VBOX + +#include "nsXPTCUtils.h" +#include "nsCOMPtr.h" +#include "nsIInterfaceInfoManager.h" +#include "nsJavaInterfaces.h" + +void +ThrowException(JNIEnv* env, const nsresult aErrorCode, const char* aMessage); + +class nsXPTCJStub : public nsXPTCStubBase +{ + nsCOMPtr mII; + nsIXPTCProxy* mOuter; + public: + NS_DECL_ISUPPORTS_INHERITED + + nsXPTCJStub(REFNSIID aIID, nsIXPTCProxy* aOuter, nsIInterfaceInfo* ii) + { + mOuter = aOuter; + mII = ii; + } + + virtual ~nsXPTCJStub() + { + } + + NS_IMETHOD GetInterfaceInfo(nsIInterfaceInfo** info) + { + *info = mII; + (*info)->AddRef(); + return NS_OK; + } + // call this method and return result + NS_IMETHOD CallMethod(PRUint16 methodIndex, + const nsXPTMethodInfo* info, + nsXPTCMiniVariant* params) + { + return mOuter->CallMethod(methodIndex, info, params); + } +}; + +NS_IMETHODIMP_(nsrefcnt) +nsXPTCJStub::AddRef() +{ + return mOuter->AddRef(); +} + +NS_IMETHODIMP_(nsrefcnt) +nsXPTCJStub::Release() +{ + return mOuter->Release(); +} + +NS_IMETHODIMP nsXPTCJStub::QueryInterface(REFNSIID aIID, void** aInstancePtr) +{ + nsIID* mIID; + mII->GetInterfaceIID(&mIID); + + if (mIID->Equals(aIID)) { + NS_ADDREF_THIS(); + *aInstancePtr = static_cast(this); + return NS_OK; + } + + return mOuter->QueryInterface(aIID, aInstancePtr); +} + +nsresult +NS_GetXPTCallStub(REFNSIID aIID, nsIXPTCProxy* aOuter, + nsISomeInterface* *aResult) +{ + NS_ENSURE_ARG(aOuter && aResult); +#if 0 + xptiInterfaceInfoManager *iim = + xptiInterfaceInfoManager::GetInterfaceInfoManagerNoAddRef(); + NS_ENSURE_TRUE(iim, NS_ERROR_NOT_INITIALIZED); + + xptiInterfaceEntry *iie = iim->GetInterfaceEntryForIID(&aIID); + if (!iie || !iie->EnsureResolved()) + return NS_ERROR_FAILURE; + + nsXPTCStubBase* newbase = new nsXPTCStubBase(aOuter, iie); + if (!newbase) + return NS_ERROR_OUT_OF_MEMORY; + + *aResult = newbase; +#else + nsCOMPtr iim = XPTI_GetInterfaceInfoManager(); + nsCOMPtr ii; + nsresult rv; + + rv = iim->GetInfoForIID(&aIID, getter_AddRefs(ii)); + if (NS_FAILED(rv)) + return rv; + + nsXPTCStubBase* newbase = new nsXPTCJStub(aIID, aOuter, ii); + if (!newbase) + return NS_ERROR_OUT_OF_MEMORY; + *aResult = newbase; +#endif + return NS_OK; +} + +void +NS_DestroyXPTCallStub(nsISomeInterface* aStub) +{ + nsXPTCStubBase* stub = static_cast(aStub); + delete(stub); +} + + +extern "C" void JAVAPROXY_NATIVE(finalizeProxy)(JNIEnv *env, jclass that, jobject aJavaProxy); + +nsresult +FindVBoxMethods(JNIEnv* env, jobject aXPCOMPath, void** aFunctions) +{ + nsresult rv = 0; + + // We only need to care about this function because the C function we offer + // is different from what the Java side expects + aFunctions[kFunc_FinalizeProxy] = (void*)JAVAPROXY_NATIVE(finalizeProxy); + + return rv; +} +#else +// Calls XPCOMGlueStartup using the given java.io.File object, and loads +// the JavaXPCOM methods from the XUL shared library. +nsresult +LoadXULMethods(JNIEnv* env, jobject aXPCOMPath, void** aFunctions) +{ + jstring pathString = GetJavaFilePath(env, aXPCOMPath); + if (!pathString) + return NS_ERROR_FAILURE; + const char* path = env->GetStringUTFChars(pathString, nsnull); + if (!path) + return NS_ERROR_OUT_OF_MEMORY; + + int len = strlen(path); + char* xpcomPath = (char*) malloc(len + sizeof(XPCOM_DLL) + + sizeof(XPCOM_FILE_PATH_SEPARATOR) + 1); + if (!xpcomPath) + return NS_ERROR_OUT_OF_MEMORY; + sprintf(xpcomPath, "%s" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL, path); + + nsresult rv = XPCOMGlueStartup(xpcomPath); + free(xpcomPath); + if (NS_FAILED(rv)) + return rv; + +#ifdef XP_WIN32 + // The JNICALL calling convention defines to "__stdcall" on Win32, which + // mangles the name. + nsDynamicFunctionLoad funcs[] = { + { "_Java_org_mozilla_xpcom_internal_MozillaImpl_initialize@8", + (NSFuncPtr*) &aFunctions[kFunc_Initialize] }, + { "_Java_org_mozilla_xpcom_internal_GREImpl_initEmbedding@20", + (NSFuncPtr*) &aFunctions[kFunc_InitEmbedding] }, + { "_Java_org_mozilla_xpcom_internal_GREImpl_termEmbedding@8", + (NSFuncPtr*) &aFunctions[kFunc_TermEmbedding] }, + { "_Java_org_mozilla_xpcom_internal_GREImpl_lockProfileDirectory@12", + (NSFuncPtr*) &aFunctions[kFunc_LockProfileDirectory] }, + { "_Java_org_mozilla_xpcom_internal_GREImpl_notifyProfile@8", + (NSFuncPtr*) &aFunctions[kFunc_NotifyProfile] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_initXPCOM@16", + (NSFuncPtr*) &aFunctions[kFunc_InitXPCOM] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_shutdownXPCOM@12", + (NSFuncPtr*) &aFunctions[kFunc_ShutdownXPCOM] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_getComponentManager@8", + (NSFuncPtr*) &aFunctions[kFunc_GetComponentManager] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_getComponentRegistrar@8", + (NSFuncPtr*) &aFunctions[kFunc_GetComponentRegistrar] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_getServiceManager@8", + (NSFuncPtr*) &aFunctions[kFunc_GetServiceManager] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMImpl_newLocalFile@16", + (NSFuncPtr*) &aFunctions[kFunc_NewLocalFile] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_callXPCOMMethod@20", + (NSFuncPtr*) &aFunctions[kFunc_CallXPCOMMethod] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_finalizeProxy@12", + (NSFuncPtr*) &aFunctions[kFunc_FinalizeProxy] }, + { "_Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_isSameXPCOMObject@16", + (NSFuncPtr*) &aFunctions[kFunc_IsSameXPCOMObject] }, + { "_Java_org_mozilla_xpcom_ProfileLock_release@16", + (NSFuncPtr*) &aFunctions[kFunc_ReleaseProfileLock] }, + { "_Java_org_mozilla_xpcom_internal_MozillaImpl_getNativeHandleFromAWT@12", + (NSFuncPtr*) &aFunctions[kFunc_GetNativeHandleFromAWT] }, + { "_Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_wrapJavaObject@16", + (NSFuncPtr*) &aFunctions[kFunc_WrapJavaObject] }, + { "_Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_wrapXPCOMObject@20", + (NSFuncPtr*) &aFunctions[kFunc_WrapXPCOMObject] }, + { nsnull, nsnull } + }; +#else + nsDynamicFunctionLoad funcs[] = { + { "Java_org_mozilla_xpcom_internal_MozillaImpl_initialize", + (NSFuncPtr*) &aFunctions[kFunc_Initialize] }, + { "Java_org_mozilla_xpcom_internal_GREImpl_initEmbedding", + (NSFuncPtr*) &aFunctions[kFunc_InitEmbedding] }, + { "Java_org_mozilla_xpcom_internal_GREImpl_termEmbedding", + (NSFuncPtr*) &aFunctions[kFunc_TermEmbedding] }, + { "Java_org_mozilla_xpcom_internal_GREImpl_lockProfileDirectory", + (NSFuncPtr*) &aFunctions[kFunc_LockProfileDirectory] }, + { "Java_org_mozilla_xpcom_internal_GREImpl_notifyProfile", + (NSFuncPtr*) &aFunctions[kFunc_NotifyProfile] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_initXPCOM", + (NSFuncPtr*) &aFunctions[kFunc_InitXPCOM] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_shutdownXPCOM", + (NSFuncPtr*) &aFunctions[kFunc_ShutdownXPCOM] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_getComponentManager", + (NSFuncPtr*) &aFunctions[kFunc_GetComponentManager] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_getComponentRegistrar", + (NSFuncPtr*) &aFunctions[kFunc_GetComponentRegistrar] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_getServiceManager", + (NSFuncPtr*) &aFunctions[kFunc_GetServiceManager] }, + { "Java_org_mozilla_xpcom_internal_XPCOMImpl_newLocalFile", + (NSFuncPtr*) &aFunctions[kFunc_NewLocalFile] }, + { "Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_callXPCOMMethod", + (NSFuncPtr*) &aFunctions[kFunc_CallXPCOMMethod] }, + { "Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_finalizeProxy", + (NSFuncPtr*) &aFunctions[kFunc_FinalizeProxy] }, + { "Java_org_mozilla_xpcom_internal_XPCOMJavaProxy_isSameXPCOMObject", + (NSFuncPtr*) &aFunctions[kFunc_IsSameXPCOMObject] }, + { "Java_org_mozilla_xpcom_ProfileLock_release", + (NSFuncPtr*) &aFunctions[kFunc_ReleaseProfileLock] }, + { "Java_org_mozilla_xpcom_internal_MozillaImpl_getNativeHandleFromAWT", + (NSFuncPtr*) &aFunctions[kFunc_GetNativeHandleFromAWT] }, + { "Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_wrapJavaObject", + (NSFuncPtr*) &aFunctions[kFunc_WrapJavaObject] }, + { "Java_org_mozilla_xpcom_internal_JavaXPCOMMethods_wrapXPCOMObject", + (NSFuncPtr*) &aFunctions[kFunc_WrapXPCOMObject] }, + { nsnull, nsnull } + }; +#endif + + rv = XPCOMGlueLoadXULFunctions(funcs); + if (NS_FAILED(rv)) + return rv; + + return NS_OK; +} + +void +ThrowException(JNIEnv* env, const nsresult aErrorCode, const char* aMessage) +{ + // Only throw this exception if one hasn't already been thrown, so we don't + // mask a previous exception/error. + if (env->ExceptionCheck()) + return; + + // If the error code we get is for an Out Of Memory error, try to throw an + // OutOfMemoryError. The JVM may have enough memory to create this error. + if (aErrorCode == NS_ERROR_OUT_OF_MEMORY) { + jclass clazz = env->FindClass("java/lang/OutOfMemoryError"); + if (clazz) { + env->ThrowNew(clazz, aMessage); + } + env->DeleteLocalRef(clazz); + return; + } + + // If the error was not handled above, then create an XPCOMException with the + // given error code. + jthrowable throwObj = nsnull; + jclass exceptionClass = env->FindClass("org/mozilla/xpcom/XPCOMException"); + if (exceptionClass) { + jmethodID mid = env->GetMethodID(exceptionClass, "", + "(JLjava/lang/String;)V"); + if (mid) { + throwObj = (jthrowable) env->NewObject(exceptionClass, mid, + (PRInt64) aErrorCode, + env->NewStringUTF(aMessage)); + } + } + NS_ASSERTION(throwObj, "Failed to create XPCOMException object"); + + // throw exception + if (throwObj) { + env->Throw(throwObj); + } +} +#endif // VBOX + +// Register the JavaXPCOM native methods. This associates a native Java +// method with its C implementation. +nsresult +RegisterNativeMethods(JNIEnv* env, void** aFunctions) +{ + JNINativeMethod mozilla_methods[] = { + { "initializeNative", "()V", + (void*) aFunctions[kFunc_Initialize] }, + { "getNativeHandleFromAWT", "(Ljava/lang/Object;)J", + (void*) aFunctions[kFunc_GetNativeHandleFromAWT] } + }; + + JNINativeMethod gre_methods[] = { + { "initEmbeddingNative", + "(Ljava/io/File;Ljava/io/File;Lorg/mozilla/xpcom/IAppFileLocProvider;)V", + (void*) aFunctions[kFunc_InitEmbedding] }, + { "termEmbedding", "()V", + (void*) aFunctions[kFunc_TermEmbedding] }, + { "lockProfileDirectory", "(Ljava/io/File;)Lorg/mozilla/xpcom/ProfileLock;", + (void*) aFunctions[kFunc_LockProfileDirectory] }, + { "notifyProfile", "()V", + (void*) aFunctions[kFunc_NotifyProfile] }, + }; + + JNINativeMethod xpcom_methods[] = { + { "initXPCOMNative", + "(Ljava/io/File;Lorg/mozilla/xpcom/IAppFileLocProvider;)Lorg/mozilla/interfaces/nsIServiceManager;", + (void*) aFunctions[kFunc_InitXPCOM] }, + { "shutdownXPCOM", "(Lorg/mozilla/interfaces/nsIServiceManager;)V", + (void*) aFunctions[kFunc_ShutdownXPCOM] }, + { "getComponentManager", "()Lorg/mozilla/interfaces/nsIComponentManager;", + (void*) aFunctions[kFunc_GetComponentManager] }, + { "getComponentRegistrar", "()Lorg/mozilla/interfaces/nsIComponentRegistrar;", + (void*) aFunctions[kFunc_GetComponentRegistrar] }, + { "getServiceManager", "()Lorg/mozilla/interfaces/nsIServiceManager;", + (void*) aFunctions[kFunc_GetServiceManager] }, + { "newLocalFile", "(Ljava/lang/String;Z)Lorg/mozilla/interfaces/nsILocalFile;", + (void*) aFunctions[kFunc_NewLocalFile] } + }; + + JNINativeMethod proxy_methods[] = { + { "callXPCOMMethod", + "(Ljava/lang/Object;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;", + (void*) aFunctions[kFunc_CallXPCOMMethod] }, + { "finalizeProxyNative", "(Ljava/lang/Object;)V", + (void*) aFunctions[kFunc_FinalizeProxy] }, + { "isSameXPCOMObject", "(Ljava/lang/Object;Ljava/lang/Object;)Z", + (void*) aFunctions[kFunc_IsSameXPCOMObject] } + }; + + JNINativeMethod lockProxy_methods[] = { + { "releaseNative", "(J)V", + (void*) aFunctions[kFunc_ReleaseProfileLock] } + }; + + JNINativeMethod util_methods[] = { + { "wrapJavaObject", "(Ljava/lang/Object;Ljava/lang/String;)J", + (void*) aFunctions[kFunc_WrapJavaObject] }, + { "wrapXPCOMObject", "(JLjava/lang/String;)Ljava/lang/Object;", + (void*) aFunctions[kFunc_WrapXPCOMObject] } + }; + + jint rc = -1; + jclass clazz = env->FindClass("org/mozilla/xpcom/internal/MozillaImpl"); + if (clazz) { + rc = env->RegisterNatives(clazz, mozilla_methods, + sizeof(mozilla_methods) / sizeof(mozilla_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + rc = -1; + clazz = env->FindClass("org/mozilla/xpcom/internal/GREImpl"); + if (clazz) { + rc = env->RegisterNatives(clazz, gre_methods, + sizeof(gre_methods) / sizeof(gre_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + rc = -1; + clazz = env->FindClass("org/mozilla/xpcom/internal/XPCOMImpl"); + if (clazz) { + rc = env->RegisterNatives(clazz, xpcom_methods, + sizeof(xpcom_methods) / sizeof(xpcom_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + rc = -1; + clazz = env->FindClass("org/mozilla/xpcom/internal/XPCOMJavaProxy"); + if (clazz) { + rc = env->RegisterNatives(clazz, proxy_methods, + sizeof(proxy_methods) / sizeof(proxy_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + rc = -1; + clazz = env->FindClass("org/mozilla/xpcom/ProfileLock"); + if (clazz) { + rc = env->RegisterNatives(clazz, lockProxy_methods, + sizeof(lockProxy_methods) / sizeof(lockProxy_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + rc = -1; + clazz = env->FindClass("org/mozilla/xpcom/internal/JavaXPCOMMethods"); + if (clazz) { + rc = env->RegisterNatives(clazz, util_methods, + sizeof(util_methods) / sizeof(util_methods[0])); + } + NS_ENSURE_TRUE(rc == 0, NS_ERROR_FAILURE); + + return NS_OK; +} + +// Load the JavaXPCOM methods from the XUL shared library, and registers them +// as Java native methods. +extern "C" JX_EXPORT void JNICALL +JXM_NATIVE(registerJavaXPCOMMethodsNative) (JNIEnv *env, jclass that, + jobject aXPCOMPath) +{ + void* functions[JX_NUM_FUNCS]; + memset(functions, 0, JX_NUM_FUNCS * sizeof(void*)); + +#ifdef VBOX + nsresult rv = FindVBoxMethods(env, aXPCOMPath, functions); + if (NS_SUCCEEDED(rv)) { + rv = RegisterNativeMethods(env, functions); + } +#else + nsresult rv = LoadXULMethods(env, aXPCOMPath, functions); + if (NS_SUCCEEDED(rv)) { + rv = RegisterNativeMethods(env, functions); + } +#endif + + if (NS_FAILED(rv)) { + ThrowException(env, rv, "Failed to register JavaXPCOM methods"); + } +} diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.cpp b/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.cpp new file mode 100644 index 00000000..c8136ec4 --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.cpp @@ -0,0 +1,1711 @@ +/* ***** 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 ***** */ + +#include "nsJavaXPTCStub.h" +#include "nsJavaWrapper.h" +#include "nsJavaXPCOMBindingUtils.h" +#include "prmem.h" +#include "nsIInterfaceInfoManager.h" +#include "nsString.h" +#include "nsString.h" +#include "nsCRT.h" +#include "nsServiceManagerUtils.h" + + +nsJavaXPTCStub::nsJavaXPTCStub(jobject aJavaObject, nsIInterfaceInfo *aIInfo, + nsresult *rv) + : mJavaStrongRef(nsnull) + , mIInfo(aIInfo) + , mMaster(nsnull) + , mWeakRefCnt(0) +{ + const nsIID *iid = nsnull; + aIInfo->GetIIDShared(&iid); + NS_ASSERTION(iid, "GetIIDShared must not fail!"); + + *rv = InitStub(*iid); + if (NS_FAILED(*rv)) + return; + + JNIEnv* env = GetJNIEnv(); + jobject weakref = env->NewObject(weakReferenceClass, + weakReferenceConstructorMID, aJavaObject); + mJavaWeakRef = env->NewGlobalRef(weakref); + mJavaRefHashCode = env->CallStaticIntMethod(systemClass, hashCodeMID, + aJavaObject); + +#ifdef DEBUG_JAVAXPCOM + char* iid_str = iid->ToString(); + LOG(("+ nsJavaXPTCStub (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) mJavaRefHashCode, (PRUint32) this, iid_str)); + PR_Free(iid_str); +#endif +} + +nsJavaXPTCStub::~nsJavaXPTCStub() +{ +} + +NS_IMETHODIMP_(nsrefcnt) +nsJavaXPTCStub::AddRefInternal() +{ + // If this is the first AddRef call, we create a strong global ref to the + // Java object to keep it from being garbage collected. + if (mRefCnt == 0) { + JNIEnv* env = GetJNIEnv(); + jobject referent = env->CallObjectMethod(mJavaWeakRef, getReferentMID); + if (!env->IsSameObject(referent, NULL)) { + mJavaStrongRef = env->NewGlobalRef(referent); + } + NS_ASSERTION(mJavaStrongRef != nsnull, "Failed to acquire strong ref"); + } + + // if this is the master interface + NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt"); + NS_ASSERT_OWNINGTHREAD(nsJavaXPTCStub); + ++mRefCnt; + NS_LOG_ADDREF(this, mRefCnt, "nsJavaXPTCStub", sizeof(*this)); + return mRefCnt; +} + +NS_IMETHODIMP_(nsrefcnt) +nsJavaXPTCStub::AddRef() +{ +#ifdef DEBUG_JAVAXPCOM_REFCNT + nsIID* iid; + mIInfo->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + int refcnt = PRInt32(mMaster ? mMaster->mRefCnt : mRefCnt) + 1; + LOG(("= nsJavaXPTCStub::AddRef (XPCOM=%08x | refcnt = %d | IID=%s)\n", + (int) this, refcnt, iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); +#endif + + nsJavaXPTCStub* master = mMaster ? mMaster : this; + return master->AddRefInternal(); +} + +NS_IMETHODIMP_(nsrefcnt) +nsJavaXPTCStub::ReleaseInternal() +{ + NS_PRECONDITION(0 != mRefCnt, "dup release"); + NS_ASSERT_OWNINGTHREAD(nsJavaXPTCStub); + --mRefCnt; + NS_LOG_RELEASE(this, mRefCnt, "nsJavaXPTCStub"); + if (mRefCnt == 0) { + // delete strong ref; allows Java object to be garbage collected + DeleteStrongRef(); + + // If we have a weak ref, we don't delete this object. + if (mWeakRefCnt == 0) { + mRefCnt = 1; /* stabilize */ + Destroy(); + delete this; + } + return 0; + } + return mRefCnt; +} + +NS_IMETHODIMP_(nsrefcnt) +nsJavaXPTCStub::Release() +{ +#ifdef DEBUG_JAVAXPCOM_REFCNT + nsIID* iid; + mIInfo->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + int refcnt = PRInt32(mMaster ? mMaster->mRefCnt : mRefCnt) - 1; + LOG(("= nsJavaXPTCStub::Release (XPCOM=%08x | refcnt = %d | IID=%s)\n", + (int) this, refcnt, iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); +#endif + + nsJavaXPTCStub* master = mMaster ? mMaster : this; + return master->ReleaseInternal(); +} + +void +nsJavaXPTCStub::Destroy() +{ + JNIEnv* env = GetJNIEnv(); + +#ifdef DEBUG_JAVAXPCOM + nsIID* iid; + mIInfo->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + LOG(("- nsJavaXPTCStub (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) mJavaRefHashCode, (PRUint32) this, iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); +#endif + + if (!mMaster) { + // delete each child stub + for (PRInt32 i = 0; i < mChildren.Count(); i++) { + delete (nsJavaXPTCStub*) mChildren[i]; + } + + // Since we are destroying this stub, also remove the mapping. + // It is possible for mJavaStrongRef to be NULL here. That is why we + // store the hash code value earlier. + if (gJavaXPCOMInitialized) { + gJavaToXPTCStubMap->Remove(mJavaRefHashCode); + } + } + + env->CallVoidMethod(mJavaWeakRef, clearReferentMID); + env->DeleteGlobalRef(mJavaWeakRef); +} + +void +nsJavaXPTCStub::ReleaseWeakRef() +{ + // if this is a child + if (mMaster) + mMaster->ReleaseWeakRef(); + + --mWeakRefCnt; + + // If there are no more associated weak refs, and no one else holds a strong + // ref to this object, then delete it. + if (mWeakRefCnt == 0 && mRefCnt == 0) { + NS_ASSERT_OWNINGTHREAD(nsJavaXPTCStub); + mRefCnt = 1; /* stabilize */ + Destroy(); + delete this; + } +} + +void +nsJavaXPTCStub::DeleteStrongRef() +{ + if (mJavaStrongRef == nsnull) + return; + + GetJNIEnv()->DeleteGlobalRef(mJavaStrongRef); + mJavaStrongRef = nsnull; +} + +NS_IMETHODIMP +nsJavaXPTCStub::QueryInterface(const nsID &aIID, void **aInstancePtr) +{ + nsresult rv; + + LOG(("JavaStub::QueryInterface()\n")); + *aInstancePtr = nsnull; + nsJavaXPTCStub *master = mMaster ? mMaster : this; + + // This helps us differentiate between the help classes. + if (aIID.Equals(NS_GET_IID(nsJavaXPTCStub))) + { + *aInstancePtr = master; + NS_ADDREF(this); + return NS_OK; + } + + // always return the master stub for nsISupports + if (aIID.Equals(NS_GET_IID(nsISupports))) + { + *aInstancePtr = master->mXPTCStub; + NS_ADDREF(master); + return NS_OK; + } + + // All Java objects support weak references + if (aIID.Equals(NS_GET_IID(nsISupportsWeakReference))) + { + *aInstancePtr = static_cast(master); + NS_ADDREF(master); + return NS_OK; + } + + // does any existing stub support the requested IID? + nsJavaXPTCStub *stub = master->FindStubSupportingIID(aIID); + if (stub) + { + *aInstancePtr = stub->mXPTCStub; + NS_ADDREF(stub); + return NS_OK; + } + + JNIEnv* env = GetJNIEnv(); + + // Query Java object + LOG(("\tCalling Java object queryInterface\n")); + jobject javaObject = env->CallObjectMethod(mJavaWeakRef, getReferentMID); + + jmethodID qiMID = 0; + jclass clazz = env->GetObjectClass(javaObject); + if (clazz) { + char* sig = "(Ljava/lang/String;)Lorg/mozilla/interfaces/nsISupports;"; + qiMID = env->GetMethodID(clazz, "queryInterface", sig); + NS_ASSERTION(qiMID, "Failed to get queryInterface method ID"); + } + + if (qiMID == 0) { + env->ExceptionClear(); + return NS_NOINTERFACE; + } + + // construct IID string + jstring iid_jstr = nsnull; + char* iid_str = aIID.ToString(); + if (iid_str) { + iid_jstr = env->NewStringUTF(iid_str); + } + if (!iid_str || !iid_jstr) { + env->ExceptionClear(); + return NS_ERROR_OUT_OF_MEMORY; + } + PR_Free(iid_str); + + // call queryInterface method + jobject obj = env->CallObjectMethod(javaObject, qiMID, iid_jstr); + if (env->ExceptionCheck()) { + env->ExceptionClear(); + return NS_ERROR_FAILURE; + } + if (!obj) + return NS_NOINTERFACE; + + // Get interface info for new java object + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr iinfo; + rv = iim->GetInfoForIID(&aIID, getter_AddRefs(iinfo)); + if (NS_FAILED(rv)) + return rv; + + stub = new nsJavaXPTCStub(obj, iinfo, &rv); + if (!stub) + return NS_ERROR_OUT_OF_MEMORY; + + if (NS_FAILED(rv)) { + delete stub; + return rv; + } + + // add stub to the master's list of children, so we can preserve + // symmetry in future QI calls. the master will delete each child + // when it is destroyed. the refcount of each child is bound to + // the refcount of the master. this is done to deal with code + // like this: + // + // nsCOMPtr bar = ...; + // nsIFoo *foo; + // { + // nsCOMPtr temp = do_QueryInterface(bar); + // foo = temp; + // } + // foo->DoStuff(); + // + // while this code is not valid XPCOM (since it is using |foo| + // after having called Release on it), such code is unfortunately + // very common in the mozilla codebase. the assumption this code + // is making is that so long as |bar| is alive, it should be valid + // to access |foo| even if the code doesn't own a strong reference + // to |foo|! clearly wrong, but we need to support it anyways. + + stub->mMaster = master; + master->mChildren.AppendElement(stub); + + *aInstancePtr = stub->mXPTCStub; + NS_ADDREF(stub); + return NS_OK; +} + +PRBool +nsJavaXPTCStub::SupportsIID(const nsID &iid) +{ + PRBool match; + nsCOMPtr iter = mIInfo; + do + { + if (NS_SUCCEEDED(iter->IsIID(&iid, &match)) && match) + return PR_TRUE; + + nsCOMPtr parent; + iter->GetParent(getter_AddRefs(parent)); + iter = parent; + } + while (iter != nsnull); + + return PR_FALSE; +} + +nsJavaXPTCStub * +nsJavaXPTCStub::FindStubSupportingIID(const nsID &iid) +{ + NS_ASSERTION(mMaster == nsnull, "this is not a master stub"); + + if (SupportsIID(iid)) + return this; + + for (PRInt32 i = 0; i < mChildren.Count(); i++) + { + nsJavaXPTCStub *child = (nsJavaXPTCStub *) mChildren[i]; + if (child->SupportsIID(iid)) + return child; + } + return nsnull; +} + +NS_IMETHODIMP +nsJavaXPTCStub::CallMethod(PRUint16 aMethodIndex, + const XPTMethodDescriptor *aMethodInfo, + nsXPTCMiniVariant *aParams) +{ +#ifdef DEBUG_JAVAXPCOM + const char* ifaceName; + mIInfo->GetNameShared(&ifaceName); + LOG(("---> (Java) %s::%s()\n", ifaceName, aMethodInfo->name)); +#endif + + nsresult rv = NS_OK; + JNIEnv* env = GetJNIEnv(); + jobject javaObject = env->CallObjectMethod(mJavaWeakRef, getReferentMID); + + nsCAutoString methodSig("("); + + // Create jvalue array to hold Java params + PRUint8 paramCount = aMethodInfo->num_args; + jvalue* java_params = nsnull; + const nsXPTParamInfo* retvalInfo = nsnull; + if (paramCount) { + java_params = new jvalue[paramCount]; + if (!java_params) + return NS_ERROR_OUT_OF_MEMORY; + + for (PRUint8 i = 0; i < paramCount && NS_SUCCEEDED(rv); i++) + { + const nsXPTParamInfo ¶mInfo = aMethodInfo->params[i]; + if (!paramInfo.IsRetval()) { + rv = SetupJavaParams(paramInfo, aMethodInfo, aMethodIndex, aParams, + aParams[i], java_params[i], methodSig); + } else { + retvalInfo = ¶mInfo; + } + } + NS_ASSERTION(NS_SUCCEEDED(rv), "SetupJavaParams failed"); + } + + // Finish method signature + if (NS_SUCCEEDED(rv)) { + methodSig.Append(')'); + if (retvalInfo) { + nsCAutoString retvalSig; + rv = GetRetvalSig(retvalInfo, aMethodInfo, aMethodIndex, aParams, + retvalSig); + methodSig.Append(retvalSig); + } else { + methodSig.Append('V'); + } + NS_ASSERTION(NS_SUCCEEDED(rv), "GetRetvalSig failed"); + } + + // Get Java method to call + jmethodID mid = nsnull; + if (NS_SUCCEEDED(rv)) { + nsCAutoString methodName; + if (XPT_MD_IS_GETTER(aMethodInfo->flags) || + XPT_MD_IS_SETTER(aMethodInfo->flags)) { + if (XPT_MD_IS_GETTER(aMethodInfo->flags)) + methodName.AppendLiteral("get"); + else + methodName.AppendLiteral("set"); + methodName.AppendASCII(aMethodInfo->name); + methodName.SetCharAt(toupper(methodName[3]), 3); + } else { + methodName.AppendASCII(aMethodInfo->name); + methodName.SetCharAt(tolower(methodName[0]), 0); + } + // If it's a Java keyword, then prepend an underscore + if (gJavaKeywords->GetEntry(methodName.get())) { + methodName.Insert('_', 0); + } + + jclass clazz = env->GetObjectClass(javaObject); + if (clazz) + mid = env->GetMethodID(clazz, methodName.get(), methodSig.get()); + NS_ASSERTION(mid, "Failed to get requested method for Java object"); + if (!mid) + rv = NS_ERROR_FAILURE; + } + + // Call method + jvalue retval; + if (NS_SUCCEEDED(rv)) { + if (!retvalInfo) { + env->CallVoidMethodA(javaObject, mid, java_params); + } else { + switch (retvalInfo->GetType().TagPart()) + { + case nsXPTType::T_I8: + retval.b = env->CallByteMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + retval.s = env->CallShortMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + retval.i = env->CallIntMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + retval.j = env->CallLongMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_FLOAT: + retval.f = env->CallFloatMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + retval.d = env->CallDoubleMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_BOOL: + retval.z = env->CallBooleanMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + retval.c = env->CallCharMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + case nsXPTType::T_IID: + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + retval.l = env->CallObjectMethodA(javaObject, mid, java_params); + break; + + case nsXPTType::T_VOID: + retval.j = env->CallLongMethodA(javaObject, mid, java_params); + break; + + default: + NS_WARNING("Unhandled retval type"); + break; + } + } + + // Check for exception from called Java function + jthrowable exp = env->ExceptionOccurred(); + if (exp) { + // If the exception is an instance of XPCOMException, then get the + // nsresult from the exception instance. Else, default to + // NS_ERROR_FAILURE. + if (env->IsInstanceOf(exp, xpcomExceptionClass)) { + jfieldID fid; + fid = env->GetFieldID(xpcomExceptionClass, "errorcode", "J"); + if (fid) { + rv = env->GetLongField(exp, fid); + } else { + rv = NS_ERROR_FAILURE; + } + NS_ASSERTION(fid, "Couldn't get 'errorcode' field of XPCOMException"); + } else { + rv = NS_ERROR_FAILURE; + } + } + } + + // Handle any 'inout', 'out' and 'retval' params + if (NS_SUCCEEDED(rv)) { + for (PRUint8 i = 0; i < paramCount; i++) + { + const nsXPTParamInfo ¶mInfo = aMethodInfo->params[i]; + if (paramInfo.IsIn() && !paramInfo.IsOut() && !paramInfo.IsDipper()) // 'in' + continue; + + // If param is null, then caller is not expecting an output value. + if (aParams[i].val.p == nsnull) + continue; + + if (!paramInfo.IsRetval()) { + rv = FinalizeJavaParams(paramInfo, aMethodInfo, aMethodIndex, aParams, + aParams[i], java_params[i]); + } else { + rv = FinalizeJavaParams(paramInfo, aMethodInfo, aMethodIndex, aParams, + aParams[i], retval); + } + } + NS_ASSERTION(NS_SUCCEEDED(rv), "FinalizeJavaParams/SetXPCOMRetval failed"); + } + + if (java_params) + delete [] java_params; + +#ifdef DEBUG + if (env->ExceptionCheck()) + env->ExceptionDescribe(); +#endif + env->ExceptionClear(); + + LOG(("<--- (Java) %s::%s()\n", ifaceName, aMethodInfo->name)); + return rv; +} + +/** + * Handle 'in', 'inout', and 'out' params + */ +nsresult +nsJavaXPTCStub::SetupJavaParams(const nsXPTParamInfo &aParamInfo, + const XPTMethodDescriptor* aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsXPTCMiniVariant &aVariant, jvalue &aJValue, + nsACString &aMethodSig) +{ + nsresult rv = NS_OK; + JNIEnv* env = GetJNIEnv(); + const nsXPTType &type = aParamInfo.GetType(); + + PRUint8 tag = type.TagPart(); + switch (tag) + { + case nsXPTType::T_I8: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.b = aVariant.val.i8; + aMethodSig.Append('B'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jbyteArray array = env->NewByteArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetByteArrayRegion(array, 0, 1, (jbyte*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[B"); + } + } + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.s = (tag == nsXPTType::T_I16) ? aVariant.val.i16 : + aVariant.val.u8; + aMethodSig.Append('S'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jshortArray array = env->NewShortArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetShortArrayRegion(array, 0, 1, (jshort*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[S"); + } + } + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.i = (tag == nsXPTType::T_I32) ? aVariant.val.i32 : + aVariant.val.u16; + aMethodSig.Append('I'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jintArray array = env->NewIntArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetIntArrayRegion(array, 0, 1, (jint*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[I"); + } + } + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.j = (tag == nsXPTType::T_I64) ? aVariant.val.i64 : + aVariant.val.u32; + aMethodSig.Append('J'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jlongArray array = env->NewLongArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetLongArrayRegion(array, 0, 1, (jlong*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[J"); + } + } + break; + + case nsXPTType::T_FLOAT: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.f = aVariant.val.f; + aMethodSig.Append('F'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jfloatArray array = env->NewFloatArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetFloatArrayRegion(array, 0, 1, (jfloat*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[F"); + } + } + break; + + // XXX how do we handle unsigned 64-bit values? + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.d = (tag == nsXPTType::T_DOUBLE) ? aVariant.val.d : + aVariant.val.u64; + aMethodSig.Append('D'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jdoubleArray array = env->NewDoubleArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetDoubleArrayRegion(array, 0, 1, (jdouble*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[D"); + } + } + break; + + case nsXPTType::T_BOOL: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.z = aVariant.val.b; + aMethodSig.Append('Z'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jbooleanArray array = env->NewBooleanArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetBooleanArrayRegion(array, 0, 1, (jboolean*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[Z"); + } + } + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + { + if (!aParamInfo.IsOut()) { // 'in' + if (tag == nsXPTType::T_CHAR) + aJValue.c = aVariant.val.c; + else + aJValue.c = aVariant.val.wc; + aMethodSig.Append('C'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jcharArray array = env->NewCharArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetCharArrayRegion(array, 0, 1, (jchar*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[C"); + } + } + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + { + void* ptr = nsnull; + if (!aParamInfo.IsOut()) { // 'in' + ptr = aVariant.val.p; + } else if (aVariant.val.p) { // 'inout' & 'out' + void** variant = static_cast(aVariant.val.p); + ptr = *variant; + } + + jobject str; + if (ptr) { + if (tag == nsXPTType::T_CHAR_STR) { + str = env->NewStringUTF((const char*) ptr); + } else { + const PRUnichar* buf = (const PRUnichar*) ptr; + str = env->NewString(buf, nsCRT::strlen(buf)); + } + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } else { + str = nsnull; + } + + if (!aParamInfo.IsOut()) { // 'in' + aJValue.l = str; + aMethodSig.AppendLiteral("Ljava/lang/String;"); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + aJValue.l = env->NewObjectArray(1, stringClass, str); + if (aJValue.l == nsnull) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[Ljava/lang/String;"); + } + } + break; + + case nsXPTType::T_IID: + { + nsID* iid = nsnull; + if (!aParamInfo.IsOut()) { // 'in' + iid = static_cast(aVariant.val.p); + } else if (aVariant.val.p) { // 'inout' & 'out' + nsID** variant = static_cast(aVariant.val.p); + iid = *variant; + } + + jobject str = nsnull; + if (iid) { + char iid_str[NSID_LENGTH]; + iid->ToProvidedString(iid_str); + str = env->NewStringUTF(iid_str); + if (!str) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + if (!aParamInfo.IsOut()) { // 'in' + aJValue.l = str; + aMethodSig.AppendLiteral("Ljava/lang/String;"); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + aJValue.l = env->NewObjectArray(1, stringClass, str); + if (aJValue.l == nsnull) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[Ljava/lang/String;"); + } + } + break; + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + nsISupports* xpcom_obj = nsnull; + if (!aParamInfo.IsOut()) { // 'in' + xpcom_obj = static_cast(aVariant.val.p); + } else if (aVariant.val.p) { // 'inout' & 'out' + nsISupports** variant = static_cast(aVariant.val.p); + xpcom_obj = *variant; + } + + nsID iid; + rv = GetIIDForMethodParam(mIInfo, aMethodInfo, aParamInfo, + aParamInfo.GetType().TagPart(), aMethodIndex, + aDispatchParams, PR_FALSE, iid); + if (NS_FAILED(rv)) + break; + + // get name of interface + char* iface_name = nsnull; + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) + break; + + rv = iim->GetNameForIID(&iid, &iface_name); + if (NS_FAILED(rv) || !iface_name) + break; + + jobject java_stub = nsnull; + if (xpcom_obj) { + // Get matching Java object for given xpcom object + jobject objLoader = env->CallObjectMethod(mJavaWeakRef, getReferentMID); + rv = NativeInterfaceToJavaObject(env, xpcom_obj, iid, objLoader, + &java_stub); + if (NS_FAILED(rv)) + break; + } + + if (!aParamInfo.IsOut()) { // 'in' + aJValue.l = java_stub; + } else { // 'inout' & 'out' + if (aVariant.val.p) { + aJValue.l = env->NewObjectArray(1, nsISupportsClass, java_stub); + if (aJValue.l == nsnull) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } else { + aJValue.l = nsnull; + } + aMethodSig.Append('['); + } + + if (tag != nsXPTType::T_INTERFACE_IS) { + aMethodSig.AppendLiteral("Lorg/mozilla/interfaces/"); + aMethodSig.AppendASCII(iface_name); + aMethodSig.Append(';'); + } else { + aMethodSig.AppendLiteral("Lorg/mozilla/interfaces/nsISupports;"); + } + + nsMemory::Free(iface_name); + } + break; + + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + { + // This only handle 'in' or 'in dipper' params. In XPIDL, the 'out' + // descriptor is mapped to 'in dipper'. + NS_PRECONDITION(aParamInfo.IsIn(), "unexpected param descriptor"); + if (!aParamInfo.IsIn()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + nsString* str = static_cast(aVariant.val.p); + if (!str) { + rv = NS_ERROR_FAILURE; + break; + } + + jstring jstr = nsnull; + if (!str->IsVoid()) { + jstr = env->NewString(str->get(), str->Length()); + if (!jstr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + aJValue.l = jstr; + aMethodSig.AppendLiteral("Ljava/lang/String;"); + } + break; + + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + { + // This only handle 'in' or 'in dipper' params. In XPIDL, the 'out' + // descriptor is mapped to 'in dipper'. + NS_PRECONDITION(aParamInfo.IsIn(), "unexpected param descriptor"); + if (!aParamInfo.IsIn()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + nsCString* str = static_cast(aVariant.val.p); + if (!str) { + rv = NS_ERROR_FAILURE; + break; + } + + jstring jstr = nsnull; + if (!str->IsVoid()) { + jstr = env->NewStringUTF(str->get()); + if (!jstr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + } + + aJValue.l = jstr; + aMethodSig.AppendLiteral("Ljava/lang/String;"); + } + break; + + // Pass the 'void*' address as a long + case nsXPTType::T_VOID: + { + if (!aParamInfo.IsOut()) { // 'in' + aJValue.j = reinterpret_cast(aVariant.val.p); + aMethodSig.Append('J'); + } else { // 'inout' & 'out' + if (aVariant.val.p) { + jlongArray array = env->NewLongArray(1); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + env->SetLongArrayRegion(array, 0, 1, (jlong*) aVariant.val.p); + aJValue.l = array; + } else { + aJValue.l = nsnull; + } + aMethodSig.AppendLiteral("[J"); + } + } + break; + + case nsXPTType::T_ARRAY: + NS_WARNING("array types are not yet supported"); + return NS_ERROR_NOT_IMPLEMENTED; + break; + + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + default: + NS_WARNING("unexpected parameter type"); + return NS_ERROR_UNEXPECTED; + } + + return rv; +} + +nsresult +nsJavaXPTCStub::GetRetvalSig(const nsXPTParamInfo* aParamInfo, + const XPTMethodDescriptor* aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsACString &aRetvalSig) +{ + PRUint8 type = aParamInfo->GetType().TagPart(); + switch (type) + { + case nsXPTType::T_I8: + aRetvalSig.Append('B'); + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + aRetvalSig.Append('S'); + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + aRetvalSig.Append('I'); + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + aRetvalSig.Append('J'); + break; + + case nsXPTType::T_FLOAT: + aRetvalSig.Append('F'); + break; + + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + aRetvalSig.Append('D'); + break; + + case nsXPTType::T_BOOL: + aRetvalSig.Append('Z'); + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + aRetvalSig.Append('C'); + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + case nsXPTType::T_IID: + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + aRetvalSig.AppendLiteral("Ljava/lang/String;"); + break; + + case nsXPTType::T_INTERFACE: + { + nsID iid; + nsresult rv = GetIIDForMethodParam(mIInfo, aMethodInfo, *aParamInfo, type, + aMethodIndex, aDispatchParams, + PR_FALSE, iid); + if (NS_FAILED(rv)) + break; + + // get name of interface + char* iface_name = nsnull; + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv)) + break; + + rv = iim->GetNameForIID(&iid, &iface_name); + if (NS_FAILED(rv) || !iface_name) + break; + + aRetvalSig.AppendLiteral("Lorg/mozilla/interfaces/"); + aRetvalSig.AppendASCII(iface_name); + aRetvalSig.Append(';'); + nsMemory::Free(iface_name); + break; + } + + case nsXPTType::T_INTERFACE_IS: + aRetvalSig.AppendLiteral("Lorg/mozilla/interfaces/nsISupports;"); + break; + + case nsXPTType::T_VOID: + aRetvalSig.Append('J'); + break; + + case nsXPTType::T_ARRAY: + NS_WARNING("array types are not yet supported"); + return NS_ERROR_NOT_IMPLEMENTED; + break; + + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + default: + NS_WARNING("unexpected parameter type"); + return NS_ERROR_UNEXPECTED; + } + + return NS_OK; +} + +/** + * Handle 'inout', 'out', and 'retval' params + */ +nsresult +nsJavaXPTCStub::FinalizeJavaParams(const nsXPTParamInfo &aParamInfo, + const XPTMethodDescriptor *aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsXPTCMiniVariant &aVariant, jvalue &aJValue) +{ + nsresult rv = NS_OK; + JNIEnv* env = GetJNIEnv(); + const nsXPTType &type = aParamInfo.GetType(); + + PRUint8 tag = type.TagPart(); + switch (tag) + { + case nsXPTType::T_I8: + { + jbyte value; + if (aParamInfo.IsRetval()) { // 'retval' + value = aJValue.b; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetByteArrayRegion((jbyteArray) aJValue.l, 0, 1, &value); + } + if (aVariant.val.p) + *((PRInt8 *) aVariant.val.p) = value; + } + break; + + case nsXPTType::T_U8: + case nsXPTType::T_I16: + { + jshort value = 0; + if (aParamInfo.IsRetval()) { // 'retval' + value = aJValue.s; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetShortArrayRegion((jshortArray) aJValue.l, 0, 1, &value); + } + + if (aVariant.val.p) { + if (tag == nsXPTType::T_U8) + *((PRUint8 *) aVariant.val.p) = value; + else + *((PRInt16 *) aVariant.val.p) = value; + } + } + break; + + case nsXPTType::T_U16: + case nsXPTType::T_I32: + { + jint value = 0; + if (aParamInfo.IsRetval()) { // 'retval' + value = aJValue.i; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetIntArrayRegion((jintArray) aJValue.l, 0, 1, &value); + } + + if (aVariant.val.p) { + if (tag == nsXPTType::T_U16) + *((PRUint16 *) aVariant.val.p) = value; + else + *((PRInt32 *) aVariant.val.p) = value; + } + } + break; + + case nsXPTType::T_U32: + case nsXPTType::T_I64: + { + jlong value = 0; + if (aParamInfo.IsRetval()) { // 'retval' + value = aJValue.j; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetLongArrayRegion((jlongArray) aJValue.l, 0, 1, &value); + } + + if (aVariant.val.p) { + if (tag == nsXPTType::T_U32) + *((PRUint32 *) aVariant.val.p) = value; + else + *((PRInt64 *) aVariant.val.p) = value; + } + } + break; + + case nsXPTType::T_FLOAT: + { + if (aParamInfo.IsRetval()) { // 'retval' + *((float *) aVariant.val.p) = aJValue.f; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetFloatArrayRegion((jfloatArray) aJValue.l, 0, 1, + (jfloat*) aVariant.val.p); + } + } + break; + + // XXX how do we handle 64-bit values? + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + { + jdouble value = 0; + if (aParamInfo.IsRetval()) { // 'retval' + value = aJValue.d; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetDoubleArrayRegion((jdoubleArray) aJValue.l, 0, 1, &value); + } + + if (aVariant.val.p) { + if (tag == nsXPTType::T_DOUBLE) + *((double *) aVariant.val.p) = value; + else + *((PRUint64 *) aVariant.val.p) = static_cast(value); + } + } + break; + + case nsXPTType::T_BOOL: + { + if (aParamInfo.IsRetval()) { // 'retval' + *((PRBool *) aVariant.val.p) = aJValue.z; + } else if (aJValue.l) { // 'inout' & 'out' + env->GetBooleanArrayRegion((jbooleanArray) aJValue.l, 0, 1, + (jboolean*) aVariant.val.p); + } + } + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + { + if (aParamInfo.IsRetval()) { // 'retval' + if (type.TagPart() == nsXPTType::T_CHAR) + *((char *) aVariant.val.p) = aJValue.c; + else + *((PRUnichar *) aVariant.val.p) = aJValue.c; + } else if (aJValue.l) { // 'inout' & 'out' + jchar* array = env->GetCharArrayElements((jcharArray) aJValue.l, + nsnull); + if (!array) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + if (type.TagPart() == nsXPTType::T_CHAR) + *((char *) aVariant.val.p) = array[0]; + else + *((PRUnichar *) aVariant.val.p) = array[0]; + + env->ReleaseCharArrayElements((jcharArray) aJValue.l, array, JNI_ABORT); + } + } + break; + + case nsXPTType::T_CHAR_STR: + { + jstring str = nsnull; + if (aParamInfo.IsRetval()) { // 'retval' + str = (jstring) aJValue.l; + } else { // 'inout' & 'out' + str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); + } + + char** variant = static_cast(aVariant.val.p); + if (str) { + // Get string buffer + const char* char_ptr = env->GetStringUTFChars(str, nsnull); + if (!char_ptr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + // If new string is different from one passed in, free old string + // and replace with new string. + if (aParamInfo.IsRetval() || + *variant == nsnull || strcmp(*variant, char_ptr) != 0) + { + if (!aParamInfo.IsRetval() && *variant) + PR_Free(*variant); + + *variant = strdup(char_ptr); + if (*variant == nsnull) { + rv = NS_ERROR_OUT_OF_MEMORY; + // don't 'break'; fall through to release chars + } + } + + // Release string buffer + env->ReleaseStringUTFChars(str, char_ptr); + } else { + // If we were passed in a string, delete it now, and set to null. + // (Only for 'inout' & 'out' params) + if (*variant && !aParamInfo.IsRetval()) { + PR_Free(*variant); + } + *variant = nsnull; + } + } + break; + + case nsXPTType::T_WCHAR_STR: + { + jstring str = nsnull; + if (aParamInfo.IsRetval()) { // 'retval' + str = (jstring) aJValue.l; + } else { // 'inout' & 'out' + str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); + } + + PRUnichar** variant = static_cast(aVariant.val.p); + if (str) { + // Get string buffer + const jchar* wchar_ptr = env->GetStringChars(str, nsnull); + if (!wchar_ptr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + // If new string is different from one passed in, free old string + // and replace with new string. We + if (aParamInfo.IsRetval() || + *variant == nsnull || nsCRT::strcmp(*variant, wchar_ptr) != 0) + { + if (!aParamInfo.IsRetval() && *variant) + PR_Free(*variant); + + PRUint32 length = nsCRT::strlen(wchar_ptr); + *variant = (PRUnichar*) PR_Malloc((length + 1) * sizeof(PRUnichar)); + if (*variant) { + memcpy(*variant, wchar_ptr, length * sizeof(PRUnichar)); + (*variant)[length] = 0; + } else { + rv = NS_ERROR_OUT_OF_MEMORY; + // don't 'break'; fall through to release chars + } + } + + // Release string buffer + env->ReleaseStringChars(str, wchar_ptr); + } else { + // If we were passed in a string, delete it now, and set to null. + // (Only for 'inout' & 'out' params) + if (*variant && !aParamInfo.IsRetval()) { + PR_Free(*variant); + } + *variant = nsnull; + } + } + break; + + case nsXPTType::T_IID: + { + jstring str = nsnull; + if (aParamInfo.IsRetval()) { // 'retval' + str = (jstring) aJValue.l; + } else { // 'inout' & 'out' + str = (jstring) env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); + } + + nsID** variant = static_cast(aVariant.val.p); + if (str) { + // Get string buffer + const char* char_ptr = env->GetStringUTFChars(str, nsnull); + if (!char_ptr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + if (!aParamInfo.IsRetval() && *variant) { + // If we were given an nsID, set it to the new string + nsID* oldIID = *variant; + oldIID->Parse(char_ptr); + } else { + // If the argument that was passed in was null, then we need to + // create a new nsID. + nsID* newIID = new nsID; + if (newIID) { + newIID->Parse(char_ptr); + *variant = newIID; + } else { + rv = NS_ERROR_OUT_OF_MEMORY; + // don't 'break'; fall through to release chars + } + } + + // Release string buffer + env->ReleaseStringUTFChars(str, char_ptr); + } else { + // If we were passed in an nsID, delete it now, and set to null. + // (Free only 'inout' & 'out' params) + if (*variant && !aParamInfo.IsRetval()) { + delete *variant; + } + *variant = nsnull; + } + } + break; + + case nsXPTType::T_INTERFACE: + case nsXPTType::T_INTERFACE_IS: + { + jobject java_obj = nsnull; + if (aParamInfo.IsRetval()) { // 'retval' + java_obj = aJValue.l; + } else if (aJValue.l) { // 'inout' & 'out' + java_obj = env->GetObjectArrayElement((jobjectArray) aJValue.l, 0); + } + + void* xpcom_obj = nsnull; + if (java_obj) { + // Get IID for this param + nsID iid; + rv = GetIIDForMethodParam(mIInfo, aMethodInfo, aParamInfo, + aParamInfo.GetType().TagPart(), aMethodIndex, + aDispatchParams, PR_FALSE, iid); + if (NS_FAILED(rv)) + break; + + // If the requested interface is nsIWeakReference, then we look for or + // create a stub for the nsISupports interface. Then we create a weak + // reference from that stub. + PRBool isWeakRef; + if (iid.Equals(NS_GET_IID(nsIWeakReference))) { + isWeakRef = PR_TRUE; + iid = NS_GET_IID(nsISupports); + } else { + isWeakRef = PR_FALSE; + } + + rv = JavaObjectToNativeInterface(env, java_obj, iid, &xpcom_obj); + if (NS_FAILED(rv)) + break; + rv = ((nsISupports*) xpcom_obj)->QueryInterface(iid, &xpcom_obj); + if (NS_FAILED(rv)) + break; + + // If the function expects a weak reference, then we need to + // create it here. + if (isWeakRef) { + nsISupports* isupports = (nsISupports*) xpcom_obj; + nsCOMPtr supportsweak = + do_QueryInterface(isupports); + if (supportsweak) { + nsWeakPtr weakref; + supportsweak->GetWeakReference(getter_AddRefs(weakref)); + NS_RELEASE(isupports); + xpcom_obj = weakref; + NS_ADDREF((nsISupports*) xpcom_obj); + } else { + xpcom_obj = nsnull; + } + } + } + + // For 'inout' params, if the resulting xpcom value is different than the + // one passed in, then we must release the incoming xpcom value. + nsISupports** variant = static_cast(aVariant.val.p); + if (aParamInfo.IsIn() && *variant) { + nsCOMPtr in = do_QueryInterface(*variant); + nsCOMPtr out = do_QueryInterface((nsISupports*) xpcom_obj); + if (in != out) { + NS_RELEASE(*variant); + } + } + + *(static_cast(aVariant.val.p)) = xpcom_obj; + } + break; + + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + { + NS_PRECONDITION(aParamInfo.IsDipper(), "string argument is not dipper"); + if (!aParamInfo.IsDipper()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + jstring jstr = (jstring) aJValue.l; + nsString* variant = static_cast(aVariant.val.p); + + if (jstr) { + // Get string buffer + const jchar* wchar_ptr = env->GetStringChars(jstr, nsnull); + if (!wchar_ptr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + variant->Assign(wchar_ptr); + + // release String buffer + env->ReleaseStringChars(jstr, wchar_ptr); + } else { + variant->SetIsVoid(PR_TRUE); + } + } + break; + + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + { + NS_PRECONDITION(aParamInfo.IsDipper(), "string argument is not dipper"); + if (!aParamInfo.IsDipper()) { + rv = NS_ERROR_UNEXPECTED; + break; + } + + jstring jstr = (jstring) aJValue.l; + nsCString* variant = static_cast(aVariant.val.p); + + if (jstr) { + // Get string buffer + const char* char_ptr = env->GetStringUTFChars(jstr, nsnull); + if (!char_ptr) { + rv = NS_ERROR_OUT_OF_MEMORY; + break; + } + + variant->Assign(char_ptr); + + // release String buffer + env->ReleaseStringUTFChars(jstr, char_ptr); + } else { + variant->SetIsVoid(PR_TRUE); + } + } + break; + + case nsXPTType::T_VOID: + { + if (aParamInfo.IsRetval()) { // 'retval' + aVariant.val.p = reinterpret_cast(aJValue.j); + } else if (aJValue.l) { // 'inout' & 'out' + env->GetLongArrayRegion((jlongArray) aJValue.l, 0, 1, + (jlong*) aVariant.val.p); + } + } + break; + + default: + NS_WARNING("unexpected parameter type"); + return NS_ERROR_UNEXPECTED; + } + + return rv; +} + +NS_IMETHODIMP +nsJavaXPTCStub::GetWeakReference(nsIWeakReference** aInstancePtr) +{ + if (mMaster) + return mMaster->GetWeakReference(aInstancePtr); + + LOG(("==> nsJavaXPTCStub::GetWeakReference()\n")); + + if (!aInstancePtr) + return NS_ERROR_NULL_POINTER; + + jobject javaObject = GetJNIEnv()->CallObjectMethod(mJavaWeakRef, + getReferentMID); + nsJavaXPTCStubWeakRef* weakref; + weakref = new nsJavaXPTCStubWeakRef(javaObject, this); + if (!weakref) + return NS_ERROR_OUT_OF_MEMORY; + + *aInstancePtr = weakref; + NS_ADDREF(*aInstancePtr); + ++mWeakRefCnt; + + return NS_OK; +} + +jobject +nsJavaXPTCStub::GetJavaObject() +{ + JNIEnv* env = GetJNIEnv(); + jobject javaObject = env->CallObjectMethod(mJavaWeakRef, getReferentMID); + +#ifdef DEBUG_JAVAXPCOM + nsIID* iid; + mIInfo->GetInterfaceIID(&iid); + char* iid_str = iid->ToString(); + LOG(("< nsJavaXPTCStub (Java=%08x | XPCOM=%08x | IID=%s)\n", + (PRUint32) mJavaRefHashCode, (PRUint32) this, iid_str)); + PR_Free(iid_str); + nsMemory::Free(iid); +#endif + + return javaObject; +} + + +/*static*/ nsresult +nsJavaXPTCStub::GetNewOrUsed(JNIEnv* env, jobject aJavaObject, + const nsIID& aIID, void** aResult) +{ + nsJavaXPTCStub* stub; + jint hash = env->CallStaticIntMethod(systemClass, hashCodeMID, aJavaObject); + nsresult rv = gJavaToXPTCStubMap->Find(hash, aIID, &stub); + NS_ENSURE_SUCCESS(rv, rv); + if (stub) { + // stub is already AddRef'd and QI'd + *aResult = stub; + return NS_OK; + } + + // If there is no corresponding XPCOM object, then that means that the + // parameter is a non-generated class (that is, it is not one of our + // Java stubs that represent an exising XPCOM object). So we need to + // create an XPCOM stub, that can route any method calls to the class. + + // Get interface info for class + nsCOMPtr + iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID, &rv)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr iinfo; + rv = iim->GetInfoForIID(&aIID, getter_AddRefs(iinfo)); + NS_ENSURE_SUCCESS(rv, rv); + + // Create XPCOM stub + stub = new nsJavaXPTCStub(aJavaObject, iinfo, &rv); + if (!stub) + return NS_ERROR_OUT_OF_MEMORY; + if (NS_FAILED(rv)) { + delete stub; + return rv; + } + + rv = gJavaToXPTCStubMap->Add(hash, stub); + if (NS_FAILED(rv)) { + delete stub; + return rv; + } + + NS_ADDREF(stub); + *aResult = stub; + + return NS_OK; +} diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.h b/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.h new file mode 100644 index 00000000..90d42c8f --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPTCStub.h @@ -0,0 +1,153 @@ +/* ***** 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 ***** */ + +#ifndef _nsJavaXPTCStub_h_ +#define _nsJavaXPTCStub_h_ + +#include "nsXPTCUtils.h" +#include "jni.h" +#include "nsVoidArray.h" +#include "nsIInterfaceInfo.h" +#include "nsCOMPtr.h" +#include "nsWeakReference.h" +#include "nsJavaXPTCStubWeakRef.h" + + +#define NS_JAVAXPTCSTUB_IID \ +{0x88dd8130, 0xebe6, 0x4431, {0x9d, 0xa7, 0xe6, 0xb7, 0x54, 0x74, 0xfb, 0x21}} + +class nsJavaXPTCStub : protected nsAutoXPTCStub, + public nsSupportsWeakReference +{ + friend class nsJavaXPTCStubWeakRef; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSISUPPORTSWEAKREFERENCE + NS_DECLARE_STATIC_IID_ACCESSOR(NS_JAVAXPTCSTUB_IID) + + nsJavaXPTCStub(jobject aJavaObject, nsIInterfaceInfo *aIInfo, + nsresult *rv); + + virtual ~nsJavaXPTCStub(); + + // call this method and return result + NS_IMETHOD CallMethod(PRUint16 aMethodIndex, + const XPTMethodDescriptor *aInfo, + nsXPTCMiniVariant *aParams); + + nsISomeInterface* GetStub() { return mXPTCStub; } + + // getter for mJavaObject + jobject GetJavaObject(); + + // Deletes the strong global ref for the Java object, so it can be garbage + // collected if necessary. See DestroyXPTCMappingEnum(). + void DeleteStrongRef(); + + /** + * Finds the associated nsJavaXPTCStub for the given Java object and IID. + * If no such stub exists, then a new one is created. + * + * @param env Java environment pointer + * @param aJavaObject Java object for which to find/create nsJavaXPTCStub + * @param aIID desired interface IID for nsJavaXPTCStub + * @param aResult on success, holds AddRef'd reference to nsJavaXPTCStub + * + * @return NS_OK if succeeded; all other return values are error codes. + */ + static nsresult GetNewOrUsed(JNIEnv* env, jobject aJavaObject, + const nsIID& aIID, void** aResult); + + +private: + NS_IMETHOD_(nsrefcnt) AddRefInternal(); + NS_IMETHOD_(nsrefcnt) ReleaseInternal(); + + // Deletes this object and its members. Called by ReleaseInternal() and + // ReleaseWeakRef(). + void Destroy(); + + // When a nsJavaXPTCStubWeakRef associated with this object is released, it + // calls this function to let this object know that there is one less weak + // ref. If there are no more weakrefs referencing this object, and no one + // holds a strong ref, then this function takes care of deleting the object. + void ReleaseWeakRef(); + + // returns a weak reference to a child supporting the specified interface + nsJavaXPTCStub * FindStubSupportingIID(const nsID &aIID); + + // returns true if this stub supports the specified interface + PRBool SupportsIID(const nsID &aIID); + + nsresult SetupJavaParams(const nsXPTParamInfo &aParamInfo, + const XPTMethodDescriptor* aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsXPTCMiniVariant &aVariant, + jvalue &aJValue, nsACString &aMethodSig); + nsresult GetRetvalSig(const nsXPTParamInfo* aParamInfo, + const XPTMethodDescriptor* aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsACString &aRetvalSig); + nsresult FinalizeJavaParams(const nsXPTParamInfo &aParamInfo, + const XPTMethodDescriptor* aMethodInfo, + PRUint16 aMethodIndex, + nsXPTCMiniVariant* aDispatchParams, + nsXPTCMiniVariant &aVariant, + jvalue &aJValue); + nsresult SetXPCOMRetval(); + + jobject mJavaWeakRef; + jobject mJavaStrongRef; + jint mJavaRefHashCode; + nsCOMPtr mIInfo; + + nsVoidArray mChildren; // weak references (cleared by the children) + nsJavaXPTCStub *mMaster; // strong reference + + nsAutoRefCnt mWeakRefCnt; // count for number of associated weak refs +}; + +#ifdef VBOX +NS_DEFINE_STATIC_IID_ACCESSOR2(nsJavaXPTCStub, NS_JAVAXPTCSTUB_IID) +#else +NS_DEFINE_STATIC_IID_ACCESSOR2(nsJavaXPTCStub, NS_JAVAXPTCSTUB_IID) +#endif + +#endif // _nsJavaXPTCStub_h_ diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.cpp b/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.cpp new file mode 100644 index 00000000..cb98fc9b --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.cpp @@ -0,0 +1,98 @@ +/* ***** 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 ***** */ + +#include "jni.h" +#include "nsJavaXPTCStubWeakRef.h" +#include "nsJavaXPTCStub.h" +#include "nsJavaXPCOMBindingUtils.h" +#include "nsIInterfaceInfoManager.h" + + +/** + * How we handle XPCOM weak references to a Java object: + * + * If XPCOM requires or asks for a weak reference of a Java object, we first + * find (or create) an nsJavaXPTCStub for that Java object. That way, there is + * always an nsJavaXPTCStub for any nsJavaXPTCStubWeakRef. However, the + * XPTCStub may not always be 'valid'; that is, its refcount may be zero if + * is not currently referenced by any XPCOM class. + * When an XPCOM method queries the referent from the weak reference, the + * weak ref checks first whether the Java object is still valid. If so, we can + * immediately return an addref'd nsJavaXPTCStub. The XPTCStub takes care of + * finding an XPTCStub for the required IID. + */ + +nsJavaXPTCStubWeakRef::nsJavaXPTCStubWeakRef(jobject aJavaObject, + nsJavaXPTCStub* aXPTCStub) + : mXPTCStub(aXPTCStub) +{ + JNIEnv* env = GetJNIEnv(); + jobject weakref = env->NewObject(weakReferenceClass, + weakReferenceConstructorMID, aJavaObject); + mWeakRef = env->NewGlobalRef(weakref); +} + +nsJavaXPTCStubWeakRef::~nsJavaXPTCStubWeakRef() +{ + JNIEnv* env = GetJNIEnv(); + env->CallVoidMethod(mWeakRef, clearReferentMID); + env->DeleteGlobalRef(mWeakRef); + mXPTCStub->ReleaseWeakRef(); +} + +NS_IMPL_ADDREF(nsJavaXPTCStubWeakRef) +NS_IMPL_RELEASE(nsJavaXPTCStubWeakRef) + +NS_IMPL_QUERY_INTERFACE1(nsJavaXPTCStubWeakRef, nsIWeakReference) + +NS_IMETHODIMP +nsJavaXPTCStubWeakRef::QueryReferent(const nsIID& aIID, void** aInstancePtr) +{ + LOG(("nsJavaXPTCStubWeakRef::QueryReferent()\n")); + + // Is weak ref still valid? + // We create a strong local ref to make sure Java object isn't garbage + // collected during this call. + JNIEnv* env = GetJNIEnv(); + jobject javaObject = env->CallObjectMethod(mWeakRef, getReferentMID); + if (env->IsSameObject(javaObject, NULL)) + return NS_ERROR_NULL_POINTER; + + // Java object has not been garbage collected, so return QI from XPTCStub. + return mXPTCStub->QueryInterface(aIID, aInstancePtr); +} + diff --git a/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.h b/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.h new file mode 100644 index 00000000..b538eecb --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsJavaXPTCStubWeakRef.h @@ -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) 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 ***** */ + +#ifndef _nsJavaXPTCStubWeakRef_h_ +#define _nsJavaXPTCStubWeakRef_h_ + +#include "jni.h" +#include "nsIWeakReference.h" + + +class nsJavaXPTCStub; + +/** + * This class represents an XPCOM weak reference to a Java object. + */ +class nsJavaXPTCStubWeakRef : public nsIWeakReference +{ +public: + nsJavaXPTCStubWeakRef(jobject aJavaObject, nsJavaXPTCStub* aXPTCStub); + virtual ~nsJavaXPTCStubWeakRef(); + NS_DECL_ISUPPORTS + NS_DECL_NSIWEAKREFERENCE + +protected: + jobject mWeakRef; + nsJavaXPTCStub* mXPTCStub; +}; + +#endif // _nsJavaXPTCStubWeakRef_h_ diff --git a/src/libs/xpcom18a4/java/src/nsThreadUtils.h b/src/libs/xpcom18a4/java/src/nsThreadUtils.h new file mode 100644 index 00000000..53f3dbdb --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsThreadUtils.h @@ -0,0 +1,399 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* ***** 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 Mozilla code. + * + * The Initial Developer of the Original Code is Google Inc. + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Darin Fisher + * + * 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 ***** */ + +#ifndef nsThreadUtils_h__ +#define nsThreadUtils_h__ + + +#ifdef VBOX +#include "nsIThread.h" + +inline already_AddRefed +do_GetMainThread() { + nsIThread *thread = nsnull; + nsIThread::GetMainThread(&thread); + return already_AddRefed(thread); +} + +#include "VBox/com/NativeEventQueue.h" + +inline already_AddRefed do_GetMainThreadQueue() +{ + com::NativeEventQueue* eq = com::NativeEventQueue::getMainEventQueue(); + NS_ASSERTION(eq != nsnull, "Must be valid"); + return eq->getIEventQueue(); +} + +#else +#include "prthread.h" +#include "prinrval.h" +#include "nsIThreadManager.h" +#include "nsIThread.h" +#include "nsIRunnable.h" +#include "nsStringGlue.h" +#include "nsCOMPtr.h" + + +// This is needed on some systems to prevent collisions between the symbols +// appearing in xpcom_core and xpcomglue. It may be unnecessary in the future +// with better toolchain support. +#ifdef MOZILLA_INTERNAL_API +# define NS_NewThread NS_NewThread_P +# define NS_GetCurrentThread NS_GetCurrentThread_P +# define NS_GetMainThread NS_GetMainThread_P +# define NS_IsMainThread NS_IsMainThread_P +# define NS_DispatchToCurrentThread NS_DispatchToCurrentThread_P +# define NS_DispatchToMainThread NS_DispatchToMainThread_P +# define NS_ProcessPendingEvents NS_ProcessPendingEvents_P +# define NS_HasPendingEvents NS_HasPendingEvents_P +# define NS_ProcessNextEvent NS_ProcessNextEvent_P +#endif + +//----------------------------------------------------------------------------- +// These methods are alternatives to the methods on nsIThreadManager, provided +// for convenience. + +/** + * Create a new thread, and optionally provide an initial event for the thread. + * + * @param result + * The resulting nsIThread object. + * @param initialEvent + * The initial event to run on this thread. This parameter may be null. + * + * @returns NS_ERROR_INVALID_ARG + * Indicates that the given name is not unique. + */ +extern NS_COM_GLUE NS_METHOD +NS_NewThread(nsIThread **result, nsIRunnable *initialEvent = nsnull); + +/** + * Get a reference to the current thread. + * + * @param result + * The resulting nsIThread object. + */ +extern NS_COM_GLUE NS_METHOD +NS_GetCurrentThread(nsIThread **result); + +/** + * Get a reference to the main thread. + * + * @param result + * The resulting nsIThread object. + */ +extern NS_COM_GLUE NS_METHOD +NS_GetMainThread(nsIThread **result); + +/** + * Test to see if the current thread is the main thread. + * + * @returns PR_TRUE if the current thread is the main thread, and PR_FALSE + * otherwise. + */ +extern NS_COM_GLUE NS_METHOD_(PRBool) +NS_IsMainThread(); + +/** + * Dispatch the given event to the current thread. + * + * @param event + * The event to dispatch. + * + * @returns NS_ERROR_INVALID_ARG + * If event is null. + */ +extern NS_COM_GLUE NS_METHOD +NS_DispatchToCurrentThread(nsIRunnable *event); + +/** + * Dispatch the given event to the main thread. + * + * @param event + * The event to dispatch. + * @param dispatchFlags + * The flags to pass to the main thread's dispatch method. + * + * @returns NS_ERROR_INVALID_ARG + * If event is null. + */ +extern NS_COM_GLUE NS_METHOD +NS_DispatchToMainThread(nsIRunnable *event, + PRUint32 dispatchFlags = NS_DISPATCH_NORMAL); + +#ifndef XPCOM_GLUE_AVOID_NSPR +/** + * Process all pending events for the given thread before returning. This + * method simply calls ProcessNextEvent on the thread while HasPendingEvents + * continues to return true and the time spent in NS_ProcessPendingEvents + * does not exceed the given timeout value. + * + * @param thread + * The thread object for which to process pending events. If null, then + * events will be processed for the current thread. + * @param timeout + * The maximum number of milliseconds to spend processing pending events. + * Events are not pre-empted to honor this timeout. Rather, the timeout + * value is simply used to determine whether or not to process another event. + * Pass PR_INTERVAL_NO_TIMEOUT to specify no timeout. + */ +extern NS_COM_GLUE NS_METHOD +NS_ProcessPendingEvents(nsIThread *thread, + PRIntervalTime timeout = PR_INTERVAL_NO_TIMEOUT); +#endif + +/** + * Shortcut for nsIThread::HasPendingEvents. + * + * It is an error to call this function when the given thread is not the + * current thread. This function will return PR_FALSE if called from some + * other thread. + * + * @param thread + * The current thread or null. + * + * @returns + * A boolean value that if "true" indicates that there are pending events + * in the current thread's event queue. + */ +extern NS_COM_GLUE PRBool +NS_HasPendingEvents(nsIThread *thread = nsnull); + +/** + * Shortcut for nsIThread::ProcessNextEvent. + * + * It is an error to call this function when the given thread is not the + * current thread. This function will simply return PR_FALSE if called + * from some other thread. + * + * @param thread + * The current thread or null. + * @param mayWait + * A boolean parameter that if "true" indicates that the method may block + * the calling thread to wait for a pending event. + * + * @returns + * A boolean value that if "true" indicates that an event from the current + * thread's event queue was processed. + */ +extern NS_COM_GLUE PRBool +NS_ProcessNextEvent(nsIThread *thread = nsnull, PRBool mayWait = PR_TRUE); + +//----------------------------------------------------------------------------- +// Helpers that work with nsCOMPtr: + +inline already_AddRefed +do_GetCurrentThread() { + nsIThread *thread = nsnull; + NS_GetCurrentThread(&thread); + return already_AddRefed(thread); +} + +inline already_AddRefed +do_GetMainThread() { + nsIThread *thread = nsnull; + NS_GetMainThread(&thread); + return already_AddRefed(thread); +} + +//----------------------------------------------------------------------------- + +#ifdef MOZILLA_INTERNAL_API +// Fast access to the current thread. Do not release the returned pointer! If +// you want to use this pointer from some other thread, then you will need to +// AddRef it. Otherwise, you should only consider this pointer valid from code +// running on the current thread. +extern NS_COM_GLUE nsIThread *NS_GetCurrentThread(); +#endif + +//----------------------------------------------------------------------------- + +#ifndef XPCOM_GLUE_AVOID_NSPR + +#undef IMETHOD_VISIBILITY +#define IMETHOD_VISIBILITY NS_COM_GLUE + +// This class is designed to be subclassed. +class NS_COM_GLUE nsRunnable : public nsIRunnable +{ +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIRUNNABLE + + nsRunnable() { + } + +protected: + virtual ~nsRunnable() { + } +}; + +#undef IMETHOD_VISIBILITY +#define IMETHOD_VISIBILITY NS_VISIBILITY_HIDDEN + +// An event that can be used to call a method on a class. The class type must +// support reference counting. +template +class nsRunnableMethod : public nsRunnable +{ +public: + typedef void (T::*Method)(); + + nsRunnableMethod(T *obj, Method method) + : mObj(obj), mMethod(method) { + NS_ADDREF(mObj); + } + + NS_IMETHOD Run() { + (mObj->*mMethod)(); + return NS_OK; + } + +private: + virtual ~nsRunnableMethod() { + NS_RELEASE(mObj); + } + + T *mObj; + Method mMethod; +}; + +// Use this helper macro like so: +// +// nsCOMPtr event = +// NS_NEW_RUNNABLE_METHOD(MyClass, myObject, HandleEvent); +// NS_DispatchToCurrentThread(event); +// +// Constraints: +// - myObject must be of type MyClass +// - MyClass must defined AddRef and Release methods +// +// NOTE: Attempts to make this a template function caused VC6 to barf :-( +// +#define NS_NEW_RUNNABLE_METHOD(class_, obj_, method_) \ + new nsRunnableMethod(obj_, &class_::method_) + +#endif // XPCOM_GLUE_AVOID_NSPR + +// This class is designed to be used when you have an event class E that has a +// pointer back to resource class R. If R goes away while E is still pending, +// then it is important to "revoke" E so that it does not try use R after R has +// been destroyed. nsRevocableEventPtr makes it easy for R to manage such +// situations: +// +// class R; +// +// class E : public nsRunnable { +// public: +// void Revoke() { +// mResource = nsnull; +// } +// private: +// R *mResource; +// }; +// +// class R { +// public: +// void EventHandled() { +// mEvent.Forget(); +// } +// private: +// nsRevocableEventPtr mEvent; +// }; +// +// void R::PostEvent() { +// // Make sure any pending event is revoked. +// mEvent->Revoke(); +// +// nsCOMPtr event = new E(); +// if (NS_SUCCEEDED(NS_DispatchToCurrentThread(event))) { +// // Keep pointer to event so we can revoke it. +// mEvent = event; +// } +// } +// +// NS_IMETHODIMP E::Run() { +// if (!mResource) +// return NS_OK; +// ... +// mResource->EventHandled(); +// return NS_OK; +// } +// +template +class nsRevocableEventPtr { +public: + nsRevocableEventPtr() + : mEvent(nsnull) { + } + + ~nsRevocableEventPtr() { + Revoke(); + } + + const nsRevocableEventPtr& operator=(T *event) { + Revoke(); + mEvent = event; + return *this; + } + + void Revoke() { + if (mEvent) { + mEvent->Revoke(); + mEvent = nsnull; + } + } + + void Forget() { + mEvent = nsnull; + } + + PRBool IsPending() { + return mEvent != nsnull; + } + +private: + // Not implemented + nsRevocableEventPtr(const nsRevocableEventPtr&); + nsRevocableEventPtr& operator=(const nsRevocableEventPtr&); + + T *mEvent; +}; +#endif + +#endif // nsThreadUtils_h__ diff --git a/src/libs/xpcom18a4/java/src/nsXPTCUtils.h b/src/libs/xpcom18a4/java/src/nsXPTCUtils.h new file mode 100644 index 00000000..9a1fe3cc --- /dev/null +++ b/src/libs/xpcom18a4/java/src/nsXPTCUtils.h @@ -0,0 +1,128 @@ +/* ***** 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 Mozilla XPCOM. + * + * The Initial Developer of the Original Code is + * the Mozilla Foundation . + * Portions created by the Initial Developer are Copyright (C) 2006 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Benjamin Smedberg - New code + * + * 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 ***** */ + +#ifndef nsXPTCUtils_h__ +#define nsXPTCUtils_h__ + +#include "xptcall.h" + +#ifdef VBOX + +#define NS_DECLARE_STATIC_IID_ACCESSOR(the_iid) \ + template \ + struct COMTypeInfo \ + { \ + static const nsIID kIID NS_HIDDEN; \ + }; \ + static const nsIID& GetIID() {return COMTypeInfo::kIID;} + + +#define NS_DEFINE_STATIC_IID_ACCESSOR2(the_interface, the_iid) \ + template \ + const nsIID the_interface::COMTypeInfo::kIID NS_HIDDEN = the_iid; + + +class nsIXPTCProxy : public nsISupports +{ +public: + NS_IMETHOD CallMethod(PRUint16 aMethodIndex, + const XPTMethodDescriptor *aInfo, + nsXPTCMiniVariant *aParams) = 0; +}; + +/** + * This is a typedef to avoid confusion between the canonical + * nsISupports* that provides object identity and an interface pointer + * for inheriting interfaces that aren't known at compile-time. + */ +typedef nsISupports nsISomeInterface; + +/** + * Get a proxy object to implement the specified interface. + * + * @param aIID The IID of the interface to implement. + * @param aOuter An object to receive method calls from the proxy object. + * The stub forwards QueryInterface/AddRef/Release to the + * outer object. The proxy object does not hold a reference to + * the outer object; it is the caller's responsibility to + * ensure that this pointer remains valid until the stub has + * been destroyed. + * @param aStub Out parameter for the new proxy object. The object is + * not addrefed. The object never destroys itself. It must be + * explicitly destroyed by calling + * NS_DestroyXPTCallStub when it is no longer needed. + */ +XPTC_PUBLIC_API(nsresult) +NS_GetXPTCallStub(REFNSIID aIID, nsIXPTCProxy* aOuter, + nsISomeInterface* *aStub); + +/** + * Destroys an XPTCall stub previously created with NS_GetXPTCallStub. + */ +XPTC_PUBLIC_API(void) +NS_DestroyXPTCallStub(nsISomeInterface* aStub); + + +#endif + + +/** + * A helper class that initializes an xptcall helper at construction + * and releases it at destruction. + */ +class nsAutoXPTCStub : protected nsIXPTCProxy +{ +public: + nsISomeInterface* mXPTCStub; + +protected: + nsAutoXPTCStub() : mXPTCStub(nsnull) { } + + nsresult + InitStub(const nsIID& aIID) + { + return NS_GetXPTCallStub(aIID, this, &mXPTCStub); + } + + ~nsAutoXPTCStub() + { + if (mXPTCStub) + NS_DestroyXPTCallStub(mXPTCStub); + } +}; + +#endif // nsXPTCUtils_h__ 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. + *

+ * This interface is similar to nsIDirectoryServiceProvider and + * nsIDirectoryServiceProvider2, except that its methods use + * java.io.File instead of nsIFile. + *

+ * + * @see Mozilla#initEmbedding + * @see Mozilla#initXPCOM + * @see + * nsIDirectoryServiceProvider + * @see + * Directory Service property names + */ +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: + *
    + *
  • true - The returned file will be + * cached by Directory Service. Subsequent requests for + * this prop will bypass the provider and use the cache. + *
    • + *
  • false - The provider will be asked + * for this prop each time it is requested.
    • + *
+ * + * @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. + *

+ * NOTE: This function must be called from the "main" thread. + *

+ * NOTE: At the present time, this function may only be called once in + * a given process. Use termEmbedding to clean up and free + * resources allocated by initEmbedding. + * + * @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. + *

+ * 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 release 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 initEmbedding if the + * embedder wishes to run with a profile. + *

+ * Normally the embedder should call lockProfileDirectory + * to lock the directory before calling this method. + *

+ * NOTE: There are two possibilities for selecting a profile: + *

    + *
  • + * Select the profile before calling initEmbedding. + * The aAppDirProvider object passed to initEmbedding + * should provide the NS_APP_USER_PROFILE_50_DIR key, and + * may also provide the following keys: + *
      + *
    • NS_APP_USER_PROFILE_LOCAL_50_DIR + *
    • NS_APP_PROFILE_DIR_STARTUP + *
    • NS_APP_PROFILE_LOCAL_DIR_STARTUP + *
    + * In this scenario notifyProfile should be called + * immediately after initEmbedding. Component + * registration information will be stored in the profile and + * JS components may be stored in the fastload cache. + *
    • + *
  • + * Select a profile some time after calling initEmbedding. + * 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. + *
    • + *
+ */ + 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 mSections; + + /** + * Creates a new INIParser instance from the INI file at the + * given path. aCharset specifies the character encoding of + * the file. + * + * @param aFilename path of INI file to parse + * @param aCharset character encoding of file + * @throws FileNotFoundException if aFilename 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 INIParser instance from the INI file at the + * given path, which is assumed to be in the UTF-8 charset. + * + * @param aFilename path of INI file to parse + * @throws FileNotFoundException if aFilename 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 INIParser instance from the given file. + * aCharset specifies the character encoding of the file. + * + * @param aFile INI file to parse + * @param aCharset character encoding of file + * @throws FileNotFoundException if aFile 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 INIParser instance from the given file, + * which is assumed to be in the UTF-8 charset. + * + * @param aFile INI file to parse + * @throws FileNotFoundException if aFile 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 aFile 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 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 null 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 null 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 + * null for the default behaviour. + * + * @return the service manager + * + * @throws XPCOMException
    + *
  • NS_ERROR_NOT_INITIALIZED - if static globals were not initialied, + * which can happen if XPCOM is reloaded, but did not completly + * shutdown.
    • + *
  • Other error codes indicate a failure during initialisation.
    • + *
+ */ + 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
    + *
  • NS_ERROR_FILE_UNRECOGNIZED_PATH - raised for unrecognized paths + * or relative paths (must supply full file path)
    • + *
+ */ + 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. + *

+ * 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: + * 

+ * 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
+ * }
+ *
+ * + * @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"). + *

+ * 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 + * null. + * + * @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 + * /Contents/Frameworks/XUL.framework/libxpcom.dylib. + */ + File grePath = findGREBundleFramework(); + if (grePath != null) { + return grePath; + } + + // Check ~/Library/Frameworks/XUL.framework/Versions//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//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 ("\Software\mozilla.org\GRE") + int gre_len = aKeyName.length(); + if (section.length() <= gre_len) { + continue; + } + + // Get the GRE subkey; that is, everything after + // "\Software\mozilla.org\GRE\" + String subkeyName = section.substring(gre_len + 1); + + // We are only interested in _immediate_ subkeys. We want + // "\Software\mozilla.org\GRE\" but not + // "\Software\mozilla.org\GRE\\". + 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. + *

+ * NOTE: This function must be called from the "main" thread. + *

+ * NOTE: At the present time, this function may only be called once in + * a given process. Use termEmbedding to clean up and free + * resources allocated by initEmbedding. + * + * @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. + *

+ * 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 release method, or by the + * termination of the JVM, whichever comes first. + * + * @throws XPCOMException if profile is already locked (with + * errorcode == NS_ERROR_FILE_ACCESS_DENIED); + * 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 initEmbedding if the + * embedder wishes to run with a profile. + *

+ * Normally the embedder should call lockProfileDirectory + * to lock the directory before calling this method. + *

+ * NOTE: There are two possibilities for selecting a profile: + *

    + *
  • + * Select the profile before calling initEmbedding. + * The aAppDirProvider object passed to initEmbedding + * should provide the NS_APP_USER_PROFILE_50_DIR key, and + * may also provide the following keys: + *
      + *
    • NS_APP_USER_PROFILE_LOCAL_50_DIR + *
    • NS_APP_PROFILE_DIR_STARTUP + *
    • NS_APP_PROFILE_LOCAL_DIR_STARTUP + *
    + * In this scenario notifyProfile should be called + * immediately after initEmbedding. Component + * registration information will be stored in the profile and + * JS components may be stored in the fastload cache. + *
    • + *
  • + * Select a profile some time after calling initEmbedding. + * 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. + *
    • + *
+ * + * @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 null 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 + * null for the default behaviour. + * + * @return the service manager + * + * @throws XPCOMException
    + *
  • NS_ERROR_NOT_INITIALIZED - if static globals were not initialied, + * which can happen if XPCOM is reloaded, but did not completly + * shutdown.
    • + *
  • Other error codes indicate a failure during initialisation.
    • + *
+ * @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
    + *
  • NS_ERROR_FILE_UNRECOGNIZED_PATH - raised for unrecognized paths + * or relative paths (must supply full file path)
    • + *
+ * @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 queryInterface method. This helper + * function provides a simple implementation. Therefore, if your class does + * not need to do anything special with queryInterface, your + * implementation would look like: + * 
+   *      public nsISupports queryInterface(String aIID) {
+   *        return XPCOM.queryInterface(this, aIID);
+   *      }
+   *
+ * + * @param aObject object to query + * @param aIID requested interface IID + * + * @return aObject if the given object supports that + * interface; + * null otherwise. + */ + public static nsISupports queryInterface(nsISupports aObject, String aIID) { + ArrayList classes = new ArrayList(); + 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. + *

+ * A version-part consists of up to four parts, all of which are optional: + *
+ * <number-a><string-b><number-c> + * <string-d (everything else)> + *

+ * A version-part may also consist of a single asterisk "*" which indicates + * "infinity". + *

+ * Numbers are base-10, and are zero if left out. + * Strings are compared bytewise. + *

+ * For additional backwards compatibility, if "string-b" is "+" then + * "number-a" is incremented by 1 and "string-b" becomes "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
+ *
+ * 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 "+" + if (str.charAt(0) == '+') { + result.numA++; + result.strB = "pre"; + } else { + // else if part is of type "..." + 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: + * <number-a><string-b><number-c> + * <string-d (everything else)>. + */ +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 <string-d (everything else)> + * 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 + * errorcode 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; null 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 + * java.lang.reflect.Proxy 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 createProxy + * + * @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 Object method calls; all other + * calls are forwarded to the XPCOM object. + * + * @param aProxy Proxy created by createProxy + * @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 aMethod + */ + 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 java.lang.Object.hashCode + * + * @param aProxy Proxy created by createProxy + * + * @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 java.lang.Object.equals + * + * @param aProxy Proxy created by createProxy + * @param aOther another object + * + * @return true if the given objects are the same; + * false 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 true if the given object is an XPCOMJavaProxy; + * false 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 createProxy + * @param aProxy2 XPCOMJavaProxy created by createProxy + * + * @return true if both proxies represent the same XPCOM object; + * false otherwise + */ + protected static native boolean isSameXPCOMObject(Object aProxy1, + Object aProxy2); + + /** + * Handles method calls of java.lang.Object.toString + * + * @param aProxy Proxy created by createProxy + * + * @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 createProxy + * @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 finalize 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 . + * + * 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); + } +} diff --git a/src/libs/xpcom18a4/java/tools/gen-nsError.pl b/src/libs/xpcom18a4/java/tools/gen-nsError.pl new file mode 100755 index 00000000..da866b83 --- /dev/null +++ b/src/libs/xpcom18a4/java/tools/gen-nsError.pl @@ -0,0 +1,161 @@ +#! /usr/bin/env perl +# ***** 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 +# Michal Ceresna. +# Portions created by the Initial Developer are Copyright (C) 2005 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Michal Ceresna (ceresna@dbai.tuwien.ac.at) +# 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 ***** + +# Generates XPCOMError.java from xpcom/base/nsError.h +# +# usage: perl gen-nsErrors.pl < /xpcom/base/nsError.h > XPCOMError.java + + +print "/* ***** BEGIN LICENSE BLOCK *****\n"; +print " * Version: MPL 1.1/GPL 2.0/LGPL 2.1\n"; +print " *\n"; +print " * The contents of this file are subject to the Mozilla Public License Version\n"; +print " * 1.1 (the \"License\"); you may not use this file except in compliance with\n"; +print " * the License. You may obtain a copy of the License at\n"; +print " * http://www.mozilla.org/MPL/\n"; +print " *\n"; +print " * Software distributed under the License is distributed on an \"AS IS\" basis,\n"; +print " * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License\n"; +print " * for the specific language governing rights and limitations under the\n"; +print " * License.\n"; +print " *\n"; +print " * The Original Code is mozilla.org code.\n"; +print " *\n"; +print " * The Initial Developer of the Original Code is\n"; +print " * Netscape Communications Corporation.\n"; +print " * Portions created by the Initial Developer are Copyright (C) 1998\n"; +print " * the Initial Developer. All Rights Reserved.\n"; +print " *\n"; +print " * Contributor(s):\n"; +print " *\n"; +print " * Alternatively, the contents of this file may be used under the terms of\n"; +print " * either of the GNU General Public License Version 2 or later (the \"GPL\"),\n"; +print " * or the GNU Lesser General Public License Version 2.1 or later (the \"LGPL\"),\n"; +print " * in which case the provisions of the GPL or the LGPL are applicable instead\n"; +print " * of those above. If you wish to allow use of your version of this file only\n"; +print " * under the terms of either the GPL or the LGPL, and not to allow others to\n"; +print " * use your version of this file under the terms of the MPL, indicate your\n"; +print " * decision by deleting the provisions above and replace them with the notice\n"; +print " * and other provisions required by the GPL or the LGPL. If you do not delete\n"; +print " * the provisions above, a recipient may use your version of this file under\n"; +print " * the terms of any one of the MPL, the GPL or the LGPL.\n"; +print " *\n"; +print " * ***** END LICENSE BLOCK ***** */\n"; + +print "\n"; +print "package org.mozilla.xpcom;\n"; +print "\n\n"; + +print "/**\n"; +print " * Mozilla error codes.\n"; +print " *\n"; +print " * THIS FILE GENERATED FROM mozilla/xpcom/base/nsError.h.\n"; +print " * PLEASE SEE THAT FILE FOR FULL DOCUMENTATION.\n"; +print " */\n"; +print "public interface XPCOMError {\n"; + +while () { + $line = $_; + + if ($prevline) { + $_ = $prevline.$_; + } + if (/(.*)\\$/) { + #splitted line + $prevline = $1; + next; + } + $prevline = ""; + + if (/^\s*#define\s+(NS_[A-Z_]+)\s+(0x)?([0-9a-fA-F]+)\s*$/) { + #define NS_ERROR_MODULE_XPCOM 1 + #define NS_ERROR_MODULE_BASE_OFFSET 0x45 + print " public static final long $1 = $2$3L;\n"; + } + elsif (/^\s*#define\s+(NS_[A-Z_]+)\s+\((NS_[A-Z_]+)\s+\+\s+(0x)?([0-9a-fA-F]+)\s*\)\s*/) { + #define NS_ERROR_NOT_INITIALIZED (NS_ERROR_BASE + 1) + #define NS_ERROR_FACTORY_EXISTS (NS_ERROR_BASE + 0x100) + print " public static final long $1 = $2 + $3$4L;\n"; + } + elsif (/^\s*#define\s+(NS_[A-Z_]+)\s+(NS_[A-Z_]+)\s\s*/) { + #define NS_ERROR_NO_INTERFACE NS_NOINTERFACE + print " public static final long $1 = $2;\n"; + } + elsif (/^\s*#define\s+(NS_[A-Z_]+)\s+\(\(nsresult\)\s*(0x)?([0-9a-fA-F]+)L?\)\s*$/) { + #define NS_ERROR_BASE ((nsresult) 0xC1F30000) + #define NS_ERROR_ABORT ((nsresult) 0x80004004L) + print " public static final long $1 = $2$3L;\n"; + } + elsif (/^\s*#define\s+(NS_[A-Z_]+)\s+NS_ERROR_GENERATE_FAILURE\s*\(\s*(NS_[A-Z_]+)\s*,\s*([0-9]+)\s*\)\s*$/) { + #define NS_BASE_STREAM_CLOSED NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_BASE, 2) + $module = $2; + $code = $3; + print " public static final long $1 = ((NS_ERROR_SEVERITY_ERROR<<31) | (($module+NS_ERROR_MODULE_BASE_OFFSET)<<16) | $code);\n"; + } + elsif (/^\s*#define\s+(NS_[A-Z_]+)\s+NS_ERROR_GENERATE_SUCCESS\s*\(\s*(NS_[A-Z_]+)\s*,\s*([0-9]+)\s*\)\s*$/) { + #define NS_SUCCESS_LOSS_OF_INSIGNIFICANT_DATA NS_ERROR_GENERATE_SUCCESS(NS_ERROR_MODULE_XPCOM, 1) + $module = $2; + $code = $3; + print " public static final long $1 = ((NS_ERROR_SEVERITY_SUCCESS<<31) | (($module+NS_ERROR_MODULE_BASE_OFFSET)<<16) | $code);\n"; + } + elsif (/^\s*\/\*(.*)\*\/\s*$/ && !/^\s*\/\*@[\{\}]\*\/\s*$/ && + !/^\s*\/\*\ -\*- Mode:/) { + #single line comment, but not + #/*@{*/, /*@}*/, + #/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ + print " /*$1*/\n"; + } + elsif (/^\s*$/) { + #empty line, but write only the first + #line from a sequence of empty lines + if (!$wasEmpty) { + print "\n"; + } + $wasEmpty = 1; + next; + } + else { + next; + } + + $wasEmpty = 0; +} + +print "}\n"; + diff --git a/src/libs/xpcom18a4/java/tools/genifaces/GenerateJavaInterfaces.cpp b/src/libs/xpcom18a4/java/tools/genifaces/GenerateJavaInterfaces.cpp new file mode 100644 index 00000000..60648beb --- /dev/null +++ b/src/libs/xpcom18a4/java/tools/genifaces/GenerateJavaInterfaces.cpp @@ -0,0 +1,952 @@ +/* ***** 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 ***** */ + +#include "nsXPCOM.h" +#include "nsString.h" +#include "nsILocalFile.h" +#include "nsIInterfaceInfoManager.h" +#include "xptinfo.h" +#include "nsCOMPtr.h" +#include "prmem.h" +#include "xptcall.h" +#ifdef VBOX +#include "nsFileStreams.h" +static nsresult +NS_NewLocalFileInputStream(nsIInputStream **aResult, + nsIFile *aFile, + PRInt32 aIOFlags = -1, + PRInt32 aPerm = -1, + PRInt32 aBehaviorFlags = 0) +{ + nsFileInputStream* in = new nsFileInputStream(); + nsresult rv; + + rv = in->Init(aFile, aIOFlags, aPerm, aBehaviorFlags); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = in); + + return rv; +} + +inline nsresult +NS_NewLocalFileOutputStream(nsIOutputStream **aResult, + nsIFile *aFile, + PRInt32 aIOFlags = -1, + PRInt32 aPerm = -1, + PRInt32 aBehaviorFlags = 0) +{ + nsFileOutputStream* in = new nsFileOutputStream(); + nsresult rv; + + rv = in->Init(aFile, aIOFlags, aPerm, aBehaviorFlags); + if (NS_SUCCEEDED(rv)) + NS_ADDREF(*aResult = in); + + return rv; +} + + +#else +#include "nsNetUtil.h" +#endif +#include "nsHashSets.h" +#include "nsIWeakReference.h" +#include + +#ifdef WIN32 +#define snprintf _snprintf +#endif + +#define WRITE_NOSCRIPT_METHODS + + +class TypeInfo +{ +public: + static nsresult GetParentInfo(nsIInterfaceInfo* aIInfo, + nsIInterfaceInfo** aParentInfo, + PRUint16* aParentMethodCount, + PRUint16* aParentConstCount) + { + nsCOMPtr parent; + nsresult rv = aIInfo->GetParent(getter_AddRefs(parent)); + NS_ENSURE_SUCCESS(rv, rv); + + if (!parent) { + *aParentInfo = nsnull; + *aParentMethodCount = 0; + return NS_OK; + } + + rv = parent->GetMethodCount(aParentMethodCount); + NS_ENSURE_SUCCESS(rv, rv); + rv = parent->GetConstantCount(aParentConstCount); + NS_ENSURE_SUCCESS(rv, rv); + + *aParentInfo = parent; + NS_ADDREF(*aParentInfo); + return rv; + } + + static nsresult GetInterfaceName(nsIInterfaceInfo* aIInfo, + PRUint16 aMethodIndex, + const nsXPTParamInfo* aParamInfo, + char** aResult) + { + static const char isupp_str[] = "nsISupports"; + + nsIID* iid; + nsresult rv = aIInfo->GetIIDForParam(aMethodIndex, aParamInfo, &iid); + if (NS_FAILED(rv)) { + // GetIIDForParam will sometimes fail to find an interface, particularly + // if that interface is not defined in an IDL file. In those cases, just + // return |nsISupports|. + // + // For example, the |onStreamComplete| method for the interface + // |nsIUnicharStreamLoaderObserver| takes a param of + // |nsIUnicharInputStream|, which is defined in a simple header file, not + // an IDL file. + *aResult = (char*) nsMemory::Clone(isupp_str, sizeof(isupp_str)); + rv = (*aResult == nsnull) ? NS_ERROR_OUT_OF_MEMORY : NS_OK; + + } else { + + // In Javaconnect, we handle weak references internally; no need for the + // |nsIWeakReference| interface. So just return |nsISupports|. + if (iid->Equals(NS_GET_IID(nsIWeakReference))) { + *aResult = (char*) nsMemory::Clone(isupp_str, sizeof(isupp_str)); + rv = (*aResult == nsnull) ? NS_ERROR_OUT_OF_MEMORY : NS_OK; + + } else { + + // Some methods take parameters of non-scriptable interfaces. But we + // only output scriptable interfaces. So if one of the param types is + // a non-scriptable interface, output |nsISupports| instead of the + // interface name. + nsCOMPtr info; + nsCOMPtr iim = + getter_AddRefs(XPTI_GetInterfaceInfoManager()); + NS_ASSERTION(iim, "could not get interface info manager"); + rv = iim->GetInfoForIID(iid, getter_AddRefs(info)); + NS_ENSURE_SUCCESS(rv, rv); + PRBool scriptable; + if (NS_SUCCEEDED(rv)) { + info->IsScriptable(&scriptable); + } + if (NS_FAILED(rv) || !scriptable) { + *aResult = (char*) nsMemory::Clone(isupp_str, sizeof(isupp_str)); + rv = (*aResult == nsnull) ? NS_ERROR_OUT_OF_MEMORY : NS_OK; + } else { + + // If is scriptable, get name for given IID + rv = iim->GetNameForIID(iid, aResult); + } + } + + nsMemory::Free(iid); + } + + return rv; + } +}; + + +static const char* kJavaKeywords[] = { + "abstract", "default", "if" , "private" , "this" , + "boolean" , "do" , "implements", "protected" , "throw" , + "break" , "double" , "import", "public" , "throws" , + "byte" , "else" , "instanceof", "return" , "transient", + "case" , "extends", "int" , "short" , "try" , + "catch" , "final" , "interface" , "static" , "void" , + "char" , "finally", "long" , "strictfp" , "volatile" , + "class" , "float" , "native" , "super" , "while" , + "const" , "for" , "new" , "switch" , + "continue", "goto" , "package" , "synchronized", + "assert" , /* added in Java 1.4 */ + "enum" , /* added in Java 5.0 */ + "clone" , /* clone is a member function of java.lang.Object */ + "finalize" /* finalize is a member function of java.lang.Object */ +}; + +#ifdef WRITE_NOSCRIPT_METHODS +// SWT uses [noscript] methods of the following interfaces, so we need to +// output the [noscript] methods for these interfaces. +static const char* kNoscriptMethodIfaces[] = { + "nsIBaseWindow", "nsIEmbeddingSiteWindow" +}; +#endif + + +class Generate +{ + nsILocalFile* mOutputDir; + nsCStringHashSet mIfaceTable; + nsCStringHashSet mJavaKeywords; +#ifdef WRITE_NOSCRIPT_METHODS + nsCStringHashSet mNoscriptMethodsTable; +#endif + +public: + Generate(nsILocalFile* aOutputDir) + : mOutputDir(aOutputDir) + { + mIfaceTable.Init(100); + + PRUint32 size = NS_ARRAY_LENGTH(kJavaKeywords); + mJavaKeywords.Init(size); + for (PRUint32 i = 0; i < size; i++) { + mJavaKeywords.Put(nsDependentCString(kJavaKeywords[i])); + } + +#ifdef WRITE_NOSCRIPT_METHODS + size = NS_ARRAY_LENGTH(kNoscriptMethodIfaces); + mNoscriptMethodsTable.Init(size); + for (PRUint32 j = 0; j < size; j++) { + mNoscriptMethodsTable.Put(nsDependentCString(kNoscriptMethodIfaces[j])); + } +#endif + } + + ~Generate() + { + } + + nsresult GenerateInterfaces() + { + nsresult rv; + + nsCOMPtr iim = + getter_AddRefs(XPTI_GetInterfaceInfoManager()); + NS_ASSERTION(iim, "could not get interface info manager"); + nsCOMPtr etor; + rv = iim->EnumerateInterfaces(getter_AddRefs(etor)); + NS_ENSURE_SUCCESS(rv, rv); + + // loop over interfaces + etor->First(); + do { + // get current interface + nsCOMPtr item; + rv = etor->CurrentItem(getter_AddRefs(item)); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr iface(do_QueryInterface(item)); + if (!iface) + break; + + // we only care about scriptable interfaces, so skip over those + // that aren't + PRBool scriptable; + iface->IsScriptable(&scriptable); + if (!scriptable) { + // XXX SWT uses non-scriptable interface 'nsIAppShell' (bug 270892), so + // include that one. + const char* iface_name; + iface->GetNameShared(&iface_name); + if (strcmp("nsIAppShell", iface_name) != 0) + continue; + } + + rv = WriteOneInterface(iface); + NS_ENSURE_SUCCESS(rv, rv); + + } while (NS_SUCCEEDED(etor->Next())); + + return NS_OK; + } + + nsresult WriteOneInterface(nsIInterfaceInfo* aIInfo) + { + nsresult rv; + + // write each interface only once + const char* iface_name; + aIInfo->GetNameShared(&iface_name); + if (mIfaceTable.Contains(nsDependentCString(iface_name))) + return NS_OK; + + // write any parent interface + nsCOMPtr parentInfo; + PRUint16 parentMethodCount, parentConstCount; + rv = TypeInfo::GetParentInfo(aIInfo, getter_AddRefs(parentInfo), + &parentMethodCount, &parentConstCount); + NS_ENSURE_SUCCESS(rv, rv); + if (parentInfo) + WriteOneInterface(parentInfo); + + mIfaceTable.Put(nsDependentCString(iface_name)); + + // create file for interface + nsCOMPtr out; + rv = OpenIfaceFileStream(iface_name, getter_AddRefs(out)); + NS_ENSURE_SUCCESS(rv, rv); + + // write contents to file + rv = WriteHeader(out, iface_name); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteInterfaceStart(out, aIInfo, parentInfo); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteIID(out, aIInfo); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteConstants(out, aIInfo, parentConstCount); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteMethods(out, aIInfo, parentMethodCount); + NS_ENSURE_SUCCESS(rv, rv); + rv = WriteInterfaceEnd(out); + NS_ENSURE_SUCCESS(rv, rv); + + rv = CloseIfaceFileStream(out); + + return rv; + } + + nsresult OpenIfaceFileStream(const char* aIfaceName, + nsIOutputStream** aResult) + { + nsresult rv; + + // create interface file in output dir + nsCOMPtr iface_file; + rv = mOutputDir->Clone(getter_AddRefs(iface_file)); + NS_ENSURE_SUCCESS(rv, rv); + nsAutoString filename; + filename.AppendASCII(aIfaceName); + filename.AppendLiteral(".java"); + rv = iface_file->Append(filename); + NS_ENSURE_SUCCESS(rv, rv); + + // create interface file + PRBool exists; + iface_file->Exists(&exists); + if (exists) + iface_file->Remove(PR_FALSE); + rv = iface_file->Create(nsIFile::NORMAL_FILE_TYPE, 0644); + NS_ENSURE_SUCCESS(rv, rv); + + // create output stream for writing to file + nsCOMPtr out; + rv = NS_NewLocalFileOutputStream(getter_AddRefs(out), iface_file); + NS_ENSURE_SUCCESS(rv, rv); + + *aResult = out; + NS_ADDREF(*aResult); + return NS_OK; + } + + nsresult CloseIfaceFileStream(nsIOutputStream* out) + { + return out->Close(); + } + + nsresult WriteHeader(nsIOutputStream* out, const char* aIfaceName) + { + static const char kHeader1[] = + "/**\n" + " * NOTE: THIS IS A GENERATED FILE. PLEASE CONSULT THE ORIGINAL IDL FILE\n" + " * FOR THE FULL DOCUMENTION AND LICENSE.\n" + " *\n" + " * @see \n **/\n\n"; + static const char kPackage[] = "package org.mozilla.interfaces;\n\n"; + + PRUint32 count; + nsresult rv = out->Write(kHeader1, sizeof(kHeader1) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + + nsCAutoString searchTerm; + searchTerm.AppendLiteral("interface+"); + searchTerm.AppendASCII(aIfaceName); + // LXR limits to 29 chars + rv = out->Write(searchTerm.get(), PR_MIN(29, searchTerm.Length()), &count); + NS_ENSURE_SUCCESS(rv, rv); + + rv = out->Write(kHeader2, sizeof(kHeader2) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(kPackage, sizeof(kPackage) - 1, &count); + return rv; + } + + nsresult WriteInterfaceStart(nsIOutputStream* out, nsIInterfaceInfo* aIInfo, + nsIInterfaceInfo* aParentInfo) + { + static const char kIfaceDecl1[] = "public interface "; + static const char kParentDecl[] = " extends "; + static const char kIfaceDecl2[] = "\n{\n"; + + const char* iface_name; + aIInfo->GetNameShared(&iface_name); + PRUint32 count; + nsresult rv = out->Write(kIfaceDecl1, sizeof(kIfaceDecl1) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(iface_name, strlen(iface_name), &count); + NS_ENSURE_SUCCESS(rv, rv); + + if (aParentInfo) { + const char* parent_name; + aParentInfo->GetNameShared(&parent_name); + rv = out->Write(kParentDecl, sizeof(kParentDecl) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(parent_name, strlen(parent_name), &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = out->Write(kIfaceDecl2, sizeof(kIfaceDecl2) - 1, &count); + return rv; + } + + nsresult WriteInterfaceEnd(nsIOutputStream* out) + { + PRUint32 count; + return out->Write("}\n", 2, &count); + } + + nsresult WriteIID(nsIOutputStream* out, nsIInterfaceInfo* aIInfo) + { + static const char kIIDDecl1[] = " public static final String "; + static const char kIIDDecl2[] = " =\n \""; + static const char kIIDDecl3[] = "\";\n\n"; + + nsIID* iid = nsnull; + aIInfo->GetInterfaceIID(&iid); + if (!iid) + return NS_ERROR_OUT_OF_MEMORY; + + // create iid field name + nsCAutoString iid_name; + const char* iface_name; + aIInfo->GetNameShared(&iface_name); + if (strncmp("ns", iface_name, 2) == 0) { + iid_name.AppendLiteral("NS_"); + iid_name.Append(iface_name + 2); + } else { + iid_name.Append(iface_name); + } + iid_name.AppendLiteral("_IID"); + ToUpperCase(iid_name); + + // get iid string + char* iid_str = iid->ToString(); + if (!iid_str) + return NS_ERROR_OUT_OF_MEMORY; + + PRUint32 count; + nsresult rv = out->Write(kIIDDecl1, sizeof(kIIDDecl1) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(iid_name.get(), iid_name.Length(), &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(kIIDDecl2, sizeof(kIIDDecl2) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(iid_str, strlen(iid_str), &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(kIIDDecl3, sizeof(kIIDDecl3) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + + // cleanup + PR_Free(iid_str); + nsMemory::Free(iid); + return NS_OK; + } + + nsresult WriteConstants(nsIOutputStream* out, nsIInterfaceInfo* aIInfo, + PRUint16 aParentConstCount) + { + static const char kConstDecl1[] = " public static final "; + static const char kConstDecl2[] = " = "; + static const char kConstDecl3[] = ";\n\n"; + + PRUint16 constCount; + nsresult rv = aIInfo->GetConstantCount(&constCount); + NS_ENSURE_SUCCESS(rv, rv); + + for (PRUint16 i = aParentConstCount; i < constCount; i++) { + const nsXPTConstant* constInfo; + rv = aIInfo->GetConstant(i, &constInfo); + NS_ENSURE_SUCCESS(rv, rv); + + PRUint32 count; + rv = out->Write(kConstDecl1, sizeof(kConstDecl1) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + const nsXPTType &type = constInfo->GetType(); + rv = WriteType(out, &type, aIInfo, nsnull, nsnull); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(" ", 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + const char* name = constInfo->GetName(); + rv = out->Write(name, strlen(name), &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(kConstDecl2, sizeof(kConstDecl2) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + + rv = WriteConstantValue(out, &type, constInfo->GetValue()); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(kConstDecl3, sizeof(kConstDecl3) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; + } + + nsresult WriteConstantValue(nsIOutputStream* out, const nsXPTType* aType, + const nsXPTCMiniVariant* aValue) + { + char buf[32]; + switch (aType->TagPart()) { + case nsXPTType::T_I8: + snprintf(buf, sizeof(buf), "%d", aValue->val.i8); + break; + + case nsXPTType::T_U8: + snprintf(buf, sizeof(buf), "%u", aValue->val.u8); + break; + + case nsXPTType::T_I16: + snprintf(buf, sizeof(buf), "%d", aValue->val.i16); + break; + + case nsXPTType::T_U16: + snprintf(buf, sizeof(buf), "%u", aValue->val.u16); + break; + + case nsXPTType::T_I32: + snprintf(buf, sizeof(buf), "%d", aValue->val.i32); + break; + + case nsXPTType::T_U32: + snprintf(buf, sizeof(buf), "%uL", aValue->val.u32); + break; + + case nsXPTType::T_I64: + snprintf(buf, sizeof(buf), "%lldL", aValue->val.i64); + break; + + case nsXPTType::T_U64: + snprintf(buf, sizeof(buf), "%lluL", aValue->val.u64); + break; + + case nsXPTType::T_FLOAT: + snprintf(buf, sizeof(buf), "%f", aValue->val.f); + break; + + case nsXPTType::T_DOUBLE: + snprintf(buf, sizeof(buf), "%f", aValue->val.d); + break; + + case nsXPTType::T_BOOL: + if (aValue->val.b) + sprintf(buf, "true"); + else + sprintf(buf, "false"); + break; + + case nsXPTType::T_CHAR: + snprintf(buf, sizeof(buf), "%c", aValue->val.c); + break; + + case nsXPTType::T_WCHAR: + snprintf(buf, sizeof(buf), "%c", aValue->val.wc); + break; + + default: + NS_WARNING("unexpected constant type"); + return NS_ERROR_UNEXPECTED; + } + + PRUint32 count; + return out->Write(buf, strlen(buf), &count); + } + + nsresult WriteMethods(nsIOutputStream* out, nsIInterfaceInfo* aIInfo, + PRUint16 aParentMethodCount) + { + PRUint16 methodCount; + nsresult rv = aIInfo->GetMethodCount(&methodCount); + NS_ENSURE_SUCCESS(rv, rv); + +#ifdef DEBUG_bird /* attributes first, then method. For making diffing easier. */ + for (int pass = 0; pass < 2; pass++) +#endif + for (PRUint16 i = aParentMethodCount; i < methodCount; i++) { + const nsXPTMethodInfo* methodInfo; + rv = aIInfo->GetMethodInfo(i, &methodInfo); + NS_ENSURE_SUCCESS(rv, rv); + +#ifdef WRITE_NOSCRIPT_METHODS + // XXX + // SWT makes use of [noscript] methods in some classes, so output them + // for those classes. + + // skip [notxpcom] methods + if (methodInfo->IsNotXPCOM()) + continue; + + // skip most hidden ([noscript]) methods + if (methodInfo->IsHidden()) { + const char* iface_name; + aIInfo->GetNameShared(&iface_name); + if (!mNoscriptMethodsTable.Contains(nsDependentCString(iface_name))) + continue; + } +#else + // skip hidden ([noscript]) or [notxpcom] methods + if (methodInfo->IsHidden() || methodInfo->IsNotXPCOM()) + continue; +#endif +#ifdef DEBUG_bird /* attributes first, then method. For making diffing easier. */ + if ((methodInfo->IsSetter() || methodInfo->IsGetter()) == pass) + continue; +#endif + + rv = WriteOneMethod(out, aIInfo, methodInfo, i); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; + } + + nsresult WriteOneMethod(nsIOutputStream* out, nsIInterfaceInfo* aIInfo, + const nsXPTMethodInfo* aMethodInfo, + PRUint16 aMethodIndex) + { + static const char kMethodDecl1[] = " public "; + static const char kVoidReturn[] = "void"; + static const char kParamSeparator[] = ", "; + static const char kMethodDecl2[] = ");\n\n"; + + PRUint32 count; + nsresult rv = out->Write(kMethodDecl1, sizeof(kMethodDecl1) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + + // write return type + PRUint8 paramCount = aMethodInfo->GetParamCount(); + const nsXPTParamInfo* resultInfo = nsnull; + for (PRUint8 i = 0; i < paramCount; i++) { + const nsXPTParamInfo ¶mInfo = aMethodInfo->GetParam(i); + if (paramInfo.IsRetval()) { + resultInfo = ¶mInfo; + break; + } + } + if (resultInfo) { + rv = WriteParam(out, aIInfo, aMethodIndex, resultInfo, 0); + } else { + rv = out->Write(kVoidReturn, sizeof(kVoidReturn) - 1, &count); + } + NS_ENSURE_SUCCESS(rv, rv); + + // write method name string + nsCAutoString method_name; + const char* name = aMethodInfo->GetName(); + if (aMethodInfo->IsGetter() || aMethodInfo->IsSetter()) { + if (aMethodInfo->IsGetter()) + method_name.AppendLiteral("get"); + else + method_name.AppendLiteral("set"); + method_name.Append(toupper(name[0])); + method_name.AppendASCII(name + 1); + } else { + method_name.Append(tolower(name[0])); + method_name.AppendASCII(name + 1); + // don't use Java keywords as method names + if (mJavaKeywords.Contains(method_name)) + method_name.Append('_'); + } + rv = out->Write(" ", 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write(method_name.get(), method_name.Length(), &count); + NS_ENSURE_SUCCESS(rv, rv); + rv = out->Write("(", 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + + // write parameters + for (PRUint8 j = 0; j < paramCount; j++) { + const nsXPTParamInfo ¶mInfo = aMethodInfo->GetParam(j); + if (paramInfo.IsRetval()) + continue; + + if (j != 0) { + rv = out->Write(kParamSeparator, sizeof(kParamSeparator) - 1, &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = WriteParam(out, aIInfo, aMethodIndex, ¶mInfo, j + 1); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = out->Write(kMethodDecl2, sizeof(kMethodDecl2) - 1, &count); + return rv; + } + + nsresult WriteParam(nsIOutputStream* out, nsIInterfaceInfo* aIInfo, + PRUint16 aMethodIndex, const nsXPTParamInfo* aParamInfo, + PRUint8 aIndex) + { + const nsXPTType &type = aParamInfo->GetType(); + nsresult rv = WriteType(out, &type, aIInfo, aMethodIndex, aParamInfo); + NS_ENSURE_SUCCESS(rv, rv); + + // if parameter is 'out' or 'inout', make it a Java array + PRUint32 count; + if (aParamInfo->IsOut() && !aParamInfo->IsRetval()) { + rv = out->Write("[]", 2, &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + // write name for parameter (but not for 'retval' param) + if (aIndex) { + char buf[10]; + snprintf(buf, sizeof(buf), " arg%d", aIndex); + rv = out->Write(buf, strlen(buf), &count); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; + } + + /** + * Write out the Java type for the given XPIDL type. + * + * NOTE: Java doesn't support unsigned types. So for any unsigned XPIDL type, + * we move up to the next largest Java type. This way we ensure that we don't + * lose any info. + */ + nsresult WriteType(nsIOutputStream* out, const nsXPTType* aType, + nsIInterfaceInfo* aIInfo, PRUint16 aMethodIndex, + const nsXPTParamInfo* aParamInfo) + { + nsresult rv; + PRUint32 count; + switch (aType->TagPart()) { + case nsXPTType::T_I8: + rv = out->Write("byte", 4, &count); + break; + + case nsXPTType::T_I16: + case nsXPTType::T_U8: + rv = out->Write("short", 5, &count); + break; + + case nsXPTType::T_I32: + case nsXPTType::T_U16: + rv = out->Write("int", 3, &count); + break; + + case nsXPTType::T_I64: + case nsXPTType::T_U32: + rv = out->Write("long", 4, &count); + break; + + case nsXPTType::T_FLOAT: + rv = out->Write("float", 5, &count); + break; + + // XXX how should we handle 64-bit values? + case nsXPTType::T_U64: + case nsXPTType::T_DOUBLE: + rv = out->Write("double", 6, &count); + break; + + case nsXPTType::T_BOOL: + rv = out->Write("boolean", 7, &count); + break; + + case nsXPTType::T_CHAR: + case nsXPTType::T_WCHAR: + rv = out->Write("char", 4, &count); + break; + + case nsXPTType::T_CHAR_STR: + case nsXPTType::T_WCHAR_STR: + case nsXPTType::T_IID: + case nsXPTType::T_ASTRING: + case nsXPTType::T_DOMSTRING: + case nsXPTType::T_UTF8STRING: + case nsXPTType::T_CSTRING: + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + rv = out->Write("String", 6, &count); + break; + + case nsXPTType::T_INTERFACE: + { + char* iface_name = nsnull; + rv = TypeInfo::GetInterfaceName(aIInfo, aMethodIndex, aParamInfo, + &iface_name); + if (NS_FAILED(rv) || !iface_name) { + rv = NS_ERROR_FAILURE; + break; + } + + rv = out->Write(iface_name, strlen(iface_name), &count); + nsMemory::Free(iface_name); + break; + } + + case nsXPTType::T_INTERFACE_IS: + rv = out->Write("nsISupports", 11, &count); + break; + + case nsXPTType::T_VOID: + rv = out->Write("int", 3, &count); + break; + + case nsXPTType::T_ARRAY: + { + // get array type + nsXPTType xpttype; + rv = aIInfo->GetTypeForParam(aMethodIndex, aParamInfo, 1, &xpttype); + if (NS_FAILED(rv)) + break; + + rv = WriteType(out, &xpttype, aIInfo, aMethodIndex, aParamInfo); + if (NS_FAILED(rv)) + break; + + rv = out->Write("[]", 2, &count); + break; + } + + default: + fprintf(stderr, "WARNING: unexpected parameter type %d\n", + aType->TagPart()); + return NS_ERROR_UNEXPECTED; + } + + return rv; + } +}; + +void PrintUsage(char** argv) +{ + static const char usage_str[] = + "Usage: %s -d path\n" + " -d output directory for Java interface files\n"; + fprintf(stderr, usage_str, argv[0]); +} +#ifdef VBOX +#include +using namespace com; + +#include +#include +#include +#include +#endif + +int main(int argc, char** argv) +{ + nsresult rv = NS_OK; + nsCOMPtr output_dir; + +#ifdef VBOX +#if defined(VBOX_PATH_APP_PRIVATE_ARCH) && defined(VBOX_PATH_SHARED_LIBS) + rv = RTR3InitExe(argc, &argv, 0); +#else + const char *pszHome = getenv("VBOX_PROGRAM_PATH"); + if (pszHome) { + size_t cchHome = strlen(pszHome); + char *pszExePath = (char *)alloca(cchHome + 32); + memcpy(pszExePath, pszHome, cchHome); + memcpy(pszExePath + cchHome, "/pythonfake", sizeof("/pythonfake")); + rc = RTR3InitEx(RTR3INIT_VER_CUR, 0, argc, &argv, pszExePath); + } else { + rv = RTR3InitExe(argc, &argv, 0); + } +#endif +#endif + + // handle command line arguments + for (int i = 1; i < argc; i++) { + if (argv[i][0] != '-') { + rv = NS_ERROR_FAILURE; + break; + } + + switch (argv[i][1]) { + case 'd': { + if (i + 1 == argc) { + fprintf(stderr, "ERROR: missing output directory after -d\n"); + rv = NS_ERROR_FAILURE; + break; + } + + // see if given path exists + rv = NS_NewNativeLocalFile(nsDependentCString(argv[++i]), PR_TRUE, + getter_AddRefs(output_dir)); + PRBool val; + if (NS_FAILED(rv) || NS_FAILED(output_dir->Exists(&val)) || !val || + NS_FAILED(output_dir->IsDirectory(&val)) || !val) + { + fprintf(stderr, + "ERROR: output directory doesn't exist / isn't a directory\n"); + rv = NS_ERROR_FAILURE; + break; + } + + break; + } + + default: { + fprintf(stderr, "ERROR: unknown option %s\n", argv[i]); + rv = NS_ERROR_FAILURE; + break; + } + } + } + + if (NS_FAILED(rv)) { + PrintUsage(argv); + return 1; + } + +#ifdef VBOX + rv = com::Initialize(); +#else + rv = NS_InitXPCOM2(nsnull, nsnull, nsnull); +#endif + NS_ENSURE_SUCCESS(rv, rv); + + Generate gen(output_dir); + rv = gen.GenerateInterfaces(); + +#ifdef VBOX + // very short-living XPCOM processes trigger problem on shutdown - ignoring it not a big deal anyway + //com::Shutdown(); +#else + NS_ShutdownXPCOM(nsnull); +#endif + return rv; +} diff --git a/src/libs/xpcom18a4/java/tools/genjifaces.xsl b/src/libs/xpcom18a4/java/tools/genjifaces.xsl new file mode 100644 index 00000000..7e754222 --- /dev/null +++ b/src/libs/xpcom18a4/java/tools/genjifaces.xsl @@ -0,0 +1,600 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + /** @file + + + + * + * DO NOT EDIT! This is a generated file. + * Generated from: src/VBox/Main/idl/VirtualBox.xidl (VirtualBox's interface definitions in XML) + * Generator: src/VBox/src/libs/xpcom18a4/java/tools/genjifaces.xsl + */ + +/* + * Copyright (C) 2010-2022 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 + */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + void + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3