diff --git a/mozilla/java/dom/src/JavaDOMSecurityContext.cpp b/mozilla/java/dom/src/JavaDOMSecurityContext.cpp new file mode 100644 index 00000000000..faab5ba8599 --- /dev/null +++ b/mozilla/java/dom/src/JavaDOMSecurityContext.cpp @@ -0,0 +1,42 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + */ +#include "JavaDOMSecurityContext.h" + +static NS_DEFINE_IID(kISecurityContextIID, NS_ISECURITYCONTEXT_IID); +static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); + +NS_IMPL_ADDREF(JavaDOMSecurityContext); +NS_IMPL_RELEASE(JavaDOMSecurityContext); + +JavaDOMSecurityContext::JavaDOMSecurityContext() { + NS_INIT_REFCNT(); +} + +JavaDOMSecurityContext::~JavaDOMSecurityContext() { +} +NS_METHOD +JavaDOMSecurityContext::QueryInterface(const nsIID& aIID, void** aInstancePtr) +{ + if (NULL == aInstancePtr) { + return NS_ERROR_NULL_POINTER; + } + *aInstancePtr = NULL; + if (aIID.Equals(kISecurityContextIID) || + aIID.Equals(kISupportsIID)) { + *aInstancePtr = (nsISecurityContext*) this; + AddRef(); + return NS_OK; + } + return NS_NOINTERFACE; +} + + +NS_METHOD +JavaDOMSecurityContext::Implies(const char* target, const char* action, PRBool *bAllowedAccess) +{ + *bAllowedAccess = PR_TRUE; + return NS_OK; +} + + diff --git a/mozilla/java/dom/src/JavaDOMSecurityContext.h b/mozilla/java/dom/src/JavaDOMSecurityContext.h new file mode 100644 index 00000000000..7b78112d45c --- /dev/null +++ b/mozilla/java/dom/src/JavaDOMSecurityContext.h @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + */ +#include "nsISecurityContext.h" + +class JavaDOMSecurityContext : public nsISecurityContext { +public: + //////////////////////////////////////////////////////////////////////////// + // from nsISupports + + NS_DECL_ISUPPORTS + + //////////////////////////////////////////////////////////////////////////// + // from nsISecurityContext: + + /** + * Get the security context to be used in LiveConnect. + * This is used for JavaScript <--> Java. + * + * @param target -- Possible target. + * @param action -- Possible action on the target. + * @return -- NS_OK if the target and action is permitted on the security context. + * -- NS_FALSE otherwise. + */ + NS_IMETHOD Implies(const char* target, const char* action, PRBool *bAllowedAccess); + JavaDOMSecurityContext(); + virtual ~JavaDOMSecurityContext(); +}; + diff --git a/mozilla/java/dom/src/Makefile b/mozilla/java/dom/src/Makefile new file mode 100644 index 00000000000..312b6127e09 --- /dev/null +++ b/mozilla/java/dom/src/Makefile @@ -0,0 +1,64 @@ +# 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 Sun Microsystems, +# Inc. Portions created by Sun are +# Copyright (C) 1999 Sun Microsystems, Inc. All +# Rights Reserved. +# +# Contributor(s): + +DEPTH = ../../.. +topsrcdir = $(DEPTH) +srcdir = . + +include $(DEPTH)/config/autoconf.mk + +JAVAHOME = $(JDKHOME) +MODULE = javadom +LIBRARY_NAME = javadom +IS_COMPONENT = 1 + +CPPSRCS = \ + nsJavaDOMImpl.cpp + +include $(topsrcdir)/config/config.mk + +ifeq ($(OS_ARCH),Linux) + INCLUDES += -I$(JAVAHOME)/include -I$(JAVAHOME)/include/linux + DSO_LDOPTS += \ + -L$(JAVAHOME)/jre/lib/i386 \ + -L$(JAVAHOME)/jre/lib/i386/classic \ + -L$(JAVAHOME)/jre/lib/i386/native_threads \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386 \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386/classic \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386/native_threads \ + -ljvm -lhpi + DEFINES += -DDISABLE_JIT +else + INCLUDES += -I$(JAVAHOME)/include -I$(JAVAHOME)/include/solaris + DSO_LDOPTS += \ + -L$(JAVAHOME)/jre/lib/sparc \ + -L$(JAVAHOME)/jre/lib/sparc/classic \ + -L$(JAVAHOME)/jre/lib/sparc/native_threads \ + -R$(JAVAHOME)/jre/lib/sparc \ + -R$(JAVAHOME)/jre/lib/sparc/classic \ + -R$(JAVAHOME)/jre/lib/sparc/native_threads \ + -ljvm -lhpi +endif + +EXPORTS = \ + nsIJavaDOM.h + +EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS)) + +include $(topsrcdir)/config/rules.mk diff --git a/mozilla/java/dom/src/Makefile.in b/mozilla/java/dom/src/Makefile.in new file mode 100644 index 00000000000..f9034788598 --- /dev/null +++ b/mozilla/java/dom/src/Makefile.in @@ -0,0 +1,64 @@ +# 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 Sun Microsystems, +# Inc. Portions created by Sun are +# Copyright (C) 1999 Sun Microsystems, Inc. All +# Rights Reserved. +# +# Contributor(s): + +DEPTH = ../../.. +topsrcdir = $(DEPTH) +srcdir = . + +include $(DEPTH)/config/autoconf.mk + +JAVAHOME = $(JDKHOME) +MODULE = javadom +LIBRARY_NAME = javadom +IS_COMPONENT = 1 + +CPPSRCS = \ + nsJavaDOMImpl.cpp + +include $(topsrcdir)/config/config.mk + +ifeq ($(OS_ARCH),Linux) + INCLUDES += -I$(JAVAHOME)/include -I$(JAVAHOME)/include/linux + DSO_LDOPTS += \ + -L$(JAVAHOME)/jre/lib/i386 \ + -L$(JAVAHOME)/jre/lib/i386/classic \ + -L$(JAVAHOME)/jre/lib/i386/native_threads \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386 \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386/classic \ + -Xlinker -rpath $(JAVAHOME)/jre/lib/i386/native_threads \ + -ljvm -lhpi + DEFINES += -DDISABLE_JIT +else + INCLUDES += -I$(JAVAHOME)/include -I$(JAVAHOME)/include/solaris + DSO_LDOPTS += \ + -L$(JAVAHOME)/jre/lib/sparc \ + -L$(JAVAHOME)/jre/lib/sparc/classic \ + -L$(JAVAHOME)/jre/lib/sparc/native_threads \ + -R$(JAVAHOME)/jre/lib/sparc \ + -R$(JAVAHOME)/jre/lib/sparc/classic \ + -R$(JAVAHOME)/jre/lib/sparc/native_threads \ + -ljvm -lhpi +endif + +EXPORTS = \ + nsIJavaDOM.h + +EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS)) + +include $(topsrcdir)/config/rules.mk diff --git a/mozilla/java/dom/src/makefile.win b/mozilla/java/dom/src/makefile.win new file mode 100644 index 00000000000..4a4ac23cf12 --- /dev/null +++ b/mozilla/java/dom/src/makefile.win @@ -0,0 +1,84 @@ +#!nmake +# +# 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 Sun Microsystems, +# Inc. Portions created by Sun are +# Copyright (C) 1999 Sun Microsystems, Inc. All +# Rights Reserved. +# +# Contributor(s): + +DEPTH=..\..\.. +IGNORE_MANIFEST=1 + +DEFINES=-D_IMPL_NS_WEB -DWIN32_LEAN_AND_MEAN +!ifdef JAVA_DOM_OJI_ENABLE +DEFINES=$(DEFINES) -DJAVA_DOM_OJI_ENABLE +!endif +MODULE=javadom +IS_COMPONENT=1 +LIBRARY_NAME=libjavadom + +CPPSRCS= \ +!ifdef JAVA_DOM_OJI_ENABLE + JavaDOMSecurityContext.cpp \ +!endif + nsJavaDOMImpl.cpp \ + $(NULL) + +CPP_OBJS= \ +!ifdef JAVA_DOM_OJI_ENABLE + .\$(OBJDIR)\JavaDOMSecurityContext.obj \ +!endif + .\$(OBJDIR)\nsJavaDOMImpl.obj \ + $(NULL) + +EXPORTS = \ + nsIJavaDOM.h + +!ifndef JAVA_DOM_OJI_ENABLE +LINCS= \ + -I$(JDKHOME)\include \ + -I$(JDKHOME)\include\win32 +!endif + +MAKE_OBJ_TYPE = DLL +DLLNAME = javadom +DLL=.\$(OBJDIR)\$(DLLNAME).dll + +LCFLAGS = \ + $(LCFLAGS) \ + $(DEFINES) \ + $(NULL) + +LLIBS= \ +!ifdef JAVA_DOM_OJI_ENABLE + $(DIST)\lib\oji.lib \ +!else + $(JDKHOME)\lib\jvm.lib \ +!endif + $(DIST)\lib\xpcom.lib \ + $(LIBNSPR) + +include <$(DEPTH)\config\config.mak> + +include <$(DEPTH)\config\rules.mak> + +install:: $(DLL) + $(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin\components + $(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib + +clobber:: + rm -f $(DIST)\bin\components\$(DLLNAME).dll + rm -f $(DIST)\lib\$(DLLNAME).lib diff --git a/mozilla/java/dom/src/nsIJavaDOM.h b/mozilla/java/dom/src/nsIJavaDOM.h new file mode 100644 index 00000000000..7ca494a8a23 --- /dev/null +++ b/mozilla/java/dom/src/nsIJavaDOM.h @@ -0,0 +1,75 @@ +/* + 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 Sun Microsystems, + Inc. Portions created by Sun are + Copyright (C) 1999 Sun Microsystems, Inc. All + Rights Reserved. + + Contributor(s): +*/ + +#ifndef __nsIJavaDOM_h__ +#define __nsIJavaDOM_h__ + +#include "nsISupports.h" +#include "nsString.h" +#include "nsIDocumentLoaderObserver.h" +#include "jni.h" + +class nsIURI; + +/* {9cc0ca50-0e31-11d3-8a61-0004ac56c4a5} */ +#define NS_IJAVADOM_IID_STR "9cc0ca50-0e31-11d3-8a61-0004ac56c4a5" +#define NS_IJAVADOM_IID \ + {0x9cc0ca50, 0x0e31, 0x11d3, \ + { 0x8a, 0x61, 0x00, 0x04, 0xac, 0x56, 0xc4, 0xa5 }} +#define NS_JAVADOM_CID \ + {0xd6b2e820, 0x9113, 0x11d3, \ + { 0x9c, 0x11, 0x0, 0x10, 0x5a , 0xe3, 0x80 , 0x1e }} + +class nsIJavaDOM : public nsIDocumentLoaderObserver { + public: + NS_DEFINE_STATIC_IID_ACCESSOR(NS_IJAVADOM_IID) + + /* nsIDocumentLoaderObserver methods */ + NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader, + nsIURI* aURL, + const char* aCommand) = 0; + + NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsresult aStatus) = 0; + + NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel) = 0; + + NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + PRUint32 aProgress, + PRUint32 aProgressMax) = 0; + + NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsString& aMsg) = 0; + + NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsresult aStatus) = 0; + + NS_IMETHOD HandleUnknownContentType(nsIDocumentLoader* loader, + nsIChannel* channel, + const char *aContentType, + const char *aCommand) = 0; +}; +#endif /* __nsIJavaDOM_h__ */ diff --git a/mozilla/java/dom/src/nsJavaDOMImpl.cpp b/mozilla/java/dom/src/nsJavaDOMImpl.cpp new file mode 100644 index 00000000000..6631f4858b7 --- /dev/null +++ b/mozilla/java/dom/src/nsJavaDOMImpl.cpp @@ -0,0 +1,730 @@ +/* + 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 Sun Microsystems, + Inc. Portions created by Sun are + Copyright (C) 1999 Sun Microsystems, Inc. All + Rights Reserved. + + Contributor(s): +*/ + +#include "prenv.h" +#include "nsISupportsUtils.h" +#include "nsIURL.h" +#include "nsIChannel.h" +#include "nsIDocument.h" +#include "nsIDocumentLoader.h" +#include "nsIDocumentLoaderObserver.h" +#include "nsIDocumentViewer.h" +#include "nsIDOMDocument.h" +#include "nsIDocShell.h" +#include "nsJavaDOMImpl.h" + +#include "nsIModule.h" +#include "nsIGenericFactory.h" + +#ifdef JAVA_DOM_OJI_ENABLE +#include "ProxyJNI.h" +#include "nsIServiceManager.h" +#endif + +#if defined(DEBUG) +#include +#include "nsIDOMElement.h" +#include "nsIDOMNodeList.h" +#include "nsIDOMNamedNodeMap.h" +static void dump_document(nsIDOMDocument* dom, const char* urlSpec); +static void dump_node(FILE* of, nsIDOMNode* node, int indent, + PRBool isMapNode); +static void dump_map(FILE* of, nsIDOMNamedNodeMap* map, int indent); +static char* strip_whitespace(const PRUnichar* input, int length); +static const char* describe_type(int type); +#endif + +#ifdef JAVA_DOM_OJI_ENABLE +static NS_DEFINE_CID(kJVMManagerCID,NS_JVMMANAGER_CID); +#endif +static NS_DEFINE_IID(kIDocShellIID, NS_IDOCSHELL_IID); +static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); +static NS_DEFINE_IID(kIJavaDOMIID, NS_IJAVADOM_IID); +static NS_DEFINE_IID(kIDocumentViewerIID, NS_IDOCUMENT_VIEWER_IID); +static NS_DEFINE_IID(kIDOMDocumentIID, NS_IDOMDOCUMENT_IID); +static NS_DEFINE_IID(kIDocumentLoaderObserverIID, NS_IDOCUMENT_LOADER_OBSERVER_IID); + +NS_IMPL_ADDREF(nsJavaDOMImpl); +NS_IMPL_RELEASE(nsJavaDOMImpl); + + +#define NS_JAVADOM_PROGID \ +"component://netscape/blackwood/java-dom" + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsJavaDOMImpl) + +static nsModuleComponentInfo components[] = +{ + { + "Java DOM", + NS_JAVADOM_CID, + NS_JAVADOM_PROGID, + nsJavaDOMImplConstructor + } +}; + +NS_IMPL_NSGETMODULE("JavaDOMModule",components); + + + +NS_IMETHODIMP nsJavaDOMImpl::QueryInterface(REFNSIID aIID, void** aInstance) +{ + if (NULL == aInstance) + return NS_ERROR_NULL_POINTER; + + *aInstance = NULL; + + if (aIID.Equals(kIJavaDOMIID)) { + *aInstance = (void*) ((nsIJavaDOM*)this); + NS_ADDREF_THIS(); + return NS_OK; + } + if (aIID.Equals(kIDocumentLoaderObserverIID)) { + *aInstance = (void*) ((nsIDocumentLoaderObserver*)this); + NS_ADDREF_THIS(); + return NS_OK; + } + if (aIID.Equals(kISupportsIID)) { + *aInstance = (void*) ((nsISupports*)this); + NS_ADDREF_THIS(); + return NS_OK; + } + + return NS_NOINTERFACE; +} + +#ifdef JAVA_DOM_OJI_ENABLE +nsJVMManager* nsJavaDOMImpl::jvmManager = NULL; +JavaDOMSecurityContext* nsJavaDOMImpl::securityContext = NULL; +#else +JavaVM* nsJavaDOMImpl::jvm = NULL; +#endif + +jclass nsJavaDOMImpl::domAccessorClass = NULL; +jclass nsJavaDOMImpl::documentClass = NULL; +jclass nsJavaDOMImpl::listenerClass = NULL; +jclass nsJavaDOMImpl::gcClass = NULL; + +jobject nsJavaDOMImpl::docListener = NULL; + +jfieldID nsJavaDOMImpl::documentPtrFID = NULL; + +jmethodID nsJavaDOMImpl::documentInitID = NULL; +jmethodID nsJavaDOMImpl::getInstanceMID = NULL; +jmethodID nsJavaDOMImpl::startURLLoadMID = NULL; +jmethodID nsJavaDOMImpl::endURLLoadMID = NULL; +jmethodID nsJavaDOMImpl::progressURLLoadMID = NULL; +jmethodID nsJavaDOMImpl::statusURLLoadMID = NULL; +jmethodID nsJavaDOMImpl::startDocumentLoadMID = NULL; +jmethodID nsJavaDOMImpl::endDocumentLoadMID = NULL; + +jmethodID nsJavaDOMImpl::gcMID = NULL; + +nsJavaDOMImpl::nsJavaDOMImpl() +{ + NS_INIT_ISUPPORTS(); + + JNIEnv* env = GetJNIEnv(); + + gcClass = env->FindClass("org/mozilla/dom/DOMGarbageCollector"); + if (!gcClass) return; + gcClass = (jclass) env->NewGlobalRef(gcClass); + if (!gcClass) return; + + gcMID = + env->GetStaticMethodID(gcClass, + "doGC", + "()V"); + if (!gcMID) return; + + domAccessorClass = env->FindClass("org/mozilla/dom/DOMAccessorImpl"); + if (!domAccessorClass) return; + domAccessorClass = (jclass) env->NewGlobalRef(domAccessorClass); + if (!domAccessorClass) return; + + getInstanceMID = + env->GetStaticMethodID(domAccessorClass, + "getInstance", + "()Lorg/mozilla/dom/DOMAccessor;"); + if (!getInstanceMID) return; + + docListener = + env->CallStaticObjectMethod(domAccessorClass, getInstanceMID); + if (!docListener) return; + docListener = (jclass) env->NewGlobalRef(docListener); + if (!docListener) return; + + listenerClass = + env->GetObjectClass(docListener); + if (!listenerClass) return; + listenerClass = (jclass) env->NewGlobalRef(listenerClass); + if (!listenerClass) return; + + documentClass = + env->FindClass("org/mozilla/dom/DocumentImpl"); + if (!documentClass) return; + documentClass = (jclass) env->NewGlobalRef(documentClass); + if (!documentClass) return; + + documentInitID = + env->GetMethodID(documentClass, "", "(J)V"); + if (!documentInitID) return; + + documentPtrFID = + env->GetFieldID(documentClass, + "p_nsIDOMNode", + "J"); + if (!documentPtrFID) return; + + startURLLoadMID = + env->GetMethodID(listenerClass, + "startURLLoad", + "(Ljava/lang/String;Ljava/lang/String;Lorg/w3c/dom/Document;)V"); + if (!startURLLoadMID) return; + + endURLLoadMID = + env->GetMethodID(listenerClass, + "endURLLoad", + "(Ljava/lang/String;ILorg/w3c/dom/Document;)V"); + if (!endURLLoadMID) return; + + progressURLLoadMID = + env->GetMethodID(listenerClass, + "progressURLLoad", + "(Ljava/lang/String;IILorg/w3c/dom/Document;)V"); + if (!progressURLLoadMID) return; + + statusURLLoadMID = + env->GetMethodID(listenerClass, + "statusURLLoad", + "(Ljava/lang/String;Ljava/lang/String;Lorg/w3c/dom/Document;)V"); + if (!statusURLLoadMID) return; + + startDocumentLoadMID = + env->GetMethodID(listenerClass, + "startDocumentLoad", + "(Ljava/lang/String;)V"); + if (!startDocumentLoadMID) return; + + endDocumentLoadMID = + env->GetMethodID(listenerClass, + "endDocumentLoad", + "(Ljava/lang/String;ILorg/w3c/dom/Document;)V"); + if (!endDocumentLoadMID) return; + + Cleanup(env); +} + +nsJavaDOMImpl::~nsJavaDOMImpl() +{ +} + +PRBool nsJavaDOMImpl::Cleanup(JNIEnv* env) +{ + if (env->ExceptionOccurred()) { + env->ExceptionDescribe(); + return PR_TRUE; + } + + return PR_FALSE; +} + +nsIDOMDocument* nsJavaDOMImpl::GetDocument(nsIDocumentLoader* loader) +{ + nsIDocShell* docshell = nsnull; + nsISupports* container = nsnull; + nsIContentViewer* contentv = nsnull; + nsIDocumentViewer* docv = nsnull; + nsIDocument* document = nsnull; + nsIDOMDocument* domDoc = nsnull; + + nsresult rv = loader->GetContainer(&container); + if (NS_SUCCEEDED(rv) && container) + rv = container->QueryInterface(kIDocShellIID, (void**) &docshell); + if (NS_SUCCEEDED(rv) && docshell) + rv = docshell->GetContentViewer(&contentv); + + if (NS_SUCCEEDED(rv) && contentv) { + rv = contentv->QueryInterface(kIDocumentViewerIID, + (void**) &docv); + if (NS_SUCCEEDED(rv) && docv) { + docv->GetDocument(document); + rv = document->QueryInterface(kIDOMDocumentIID, + (void**) &domDoc); + if (NS_SUCCEEDED(rv) && docv) { + return domDoc; + } + } + } + + fprintf(stderr, + "nsJavaDOMImpl::GetDocument: failed: " + "container=%x, webshell=%x, contentViewer=%x, " + "documentViewer=%x, document=%x, " + "domDocument=%x, error=%x\n", + (unsigned) (void*) container, + (unsigned) (void*) docshell, + (unsigned) (void*) contentv, + (unsigned) (void*) docv, + (unsigned) (void*) document, + (unsigned) (void*) domDoc, + rv); + return NULL; +} + +// convert nsIDOMDocument to org.mozilla.dom.DocumentImpl +jobject nsJavaDOMImpl::CaffienateDOMDocument(nsIDOMDocument* domDoc) +{ + if (!domDoc) return NULL; + JNIEnv* env = GetJNIEnv(); + +// jobject jdoc = env->AllocObject(documentClass); + jobject jdoc = env->NewObject(documentClass, + documentInitID, + (jlong) (void*) domDoc); + if (!jdoc) return NULL; +// env->SetLongField(jdoc, documentPtrFID, (jlong) (void*) domDoc); + if (Cleanup(env) == PR_TRUE) return NULL; + + return jdoc; +} + +/* nsIDocumentLoaderObserver methods */ + +NS_IMETHODIMP nsJavaDOMImpl::OnStartDocumentLoad(nsIDocumentLoader* loader, + nsIURI* aURL, + const char* aCommand) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + if (aURL) + aURL->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + env->CallVoidMethod(docListener, + startDocumentLoadMID, + jURL); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::OnEndDocumentLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsresult aStatus) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + nsIURI* url = nsnull; + if (channel && NS_SUCCEEDED(channel->GetURI(&url))) + url->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + nsIDOMDocument* domDoc = GetDocument(loader); + jobject jdoc = CaffienateDOMDocument(domDoc); + + env->CallVoidMethod(docListener, + endDocumentLoadMID, + jURL, + (jint) aStatus, + jdoc); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::OnStartURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + nsIURI* url = nsnull; + if (channel && NS_SUCCEEDED(channel->GetURI(&url))) + url->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + char* contentType = (char*) ""; + if (channel) + channel->GetContentType(&contentType); + if (!contentType) + contentType = (char*) ""; + jstring jContentType = env->NewStringUTF(contentType); + if (!jContentType) return NS_ERROR_FAILURE; + + nsIDOMDocument* domDoc = GetDocument(loader); + jobject jdoc = CaffienateDOMDocument(domDoc); + + env->CallVoidMethod(docListener, + startURLLoadMID, + jURL, + jContentType, + jdoc); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::OnProgressURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + PRUint32 aProgress, + PRUint32 aProgressMax) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + nsIURI* url = nsnull; + if (channel && NS_SUCCEEDED(channel->GetURI(&url))) + url->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + nsIDOMDocument* domDoc = GetDocument(loader); + jobject jdoc = CaffienateDOMDocument(domDoc); + + env->CallVoidMethod(docListener, + progressURLLoadMID, + jURL, + (jint) aProgress, + (jint) aProgressMax, + jdoc); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::OnStatusURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsString& aMsg) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + nsIURI* url = nsnull; + if (channel && NS_SUCCEEDED(channel->GetURI(&url))) + url->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + const PRUnichar* cMsg = aMsg.GetUnicode(); + jstring jMessage = env->NewString(cMsg, aMsg.Length()); + if (!jMessage) return NS_ERROR_FAILURE; + + nsIDOMDocument* domDoc = GetDocument(loader); + jobject jdoc = CaffienateDOMDocument(domDoc); + + env->CallVoidMethod(docListener, + statusURLLoadMID, + jURL, + jMessage, + jdoc); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::OnEndURLLoad(nsIDocumentLoader* loader, + nsIChannel* channel, + nsresult aStatus) +{ + JNIEnv* env = GetJNIEnv(); + char* urlSpec = (char*) ""; + nsIURI* url = nsnull; + if (channel && NS_SUCCEEDED(channel->GetURI(&url))) + url->GetSpec(&urlSpec); + jstring jURL = env->NewStringUTF(urlSpec); + if (!jURL) return NS_ERROR_FAILURE; + + nsIDOMDocument* domDoc = GetDocument(loader); + jobject jdoc = CaffienateDOMDocument(domDoc); + +#if defined(DEBUG) + dump_document(domDoc, urlSpec); +#endif + + env->CallVoidMethod(docListener, + endURLLoadMID, + jURL, + (jint) aStatus, + jdoc); + if (Cleanup(env) == PR_TRUE) return NS_ERROR_FAILURE; + + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + +NS_IMETHODIMP nsJavaDOMImpl::HandleUnknownContentType(nsIDocumentLoader* loader, + nsIChannel* channel, + const char *aContentType, + const char *aCommand) +{ + JNIEnv* env = GetJNIEnv(); + env->CallStaticVoidMethod(gcClass, gcMID); + Cleanup(env); + return NS_OK; +} + + +JNIEnv* nsJavaDOMImpl::GetJNIEnv() { + JNIEnv* env; +#ifdef JAVA_DOM_OJI_ENABLE + nsresult result; + if (!jvmManager) { + NS_WITH_SERVICE(nsIJVMManager, _jvmManager, kJVMManagerCID, &result); + if (NS_SUCCEEDED(result)) { + jvmManager = (nsJVMManager*)((nsIJVMManager*)_jvmManager); + } + } + if (!jvmManager) { + return NULL; + } + jvmManager->CreateProxyJNI(NULL,&env); +// if (!securityContext) { +// securityContext = new JavaDOMSecurityContext(); +// } + // SetSecurityContext(env,securityContext); + SetSecurityContext(env, new JavaDOMSecurityContext()); +#else /* JAVA_DOM_OJI_ENABLE */ + if (!jvm) { + StartJVM(); + } +#ifdef XP_PC + jvm->AttachCurrentThread((void**)&env,NULL); +#else + jvm->AttachCurrentThread(&env,NULL); +#endif +#endif /* JAVA_DOM_OJI_ENABLE */ + return env; +} + +#ifndef JAVA_DOM_OJI_ENABLE +void nsJavaDOMImpl::StartJVM(void) { + jsize jvmCount; + JNI_GetCreatedJavaVMs(&jvm, 1, &jvmCount); + if (jvmCount) { + return; + } + + JNIEnv *env = NULL; + JDK1_1InitArgs vm_args; + JNI_GetDefaultJavaVMInitArgs(&vm_args); + vm_args.version = 0x00010001; + vm_args.verifyMode = JNI_TRUE; +#ifdef DEBUG + vm_args.verbose = JNI_TRUE; + vm_args.enableVerboseGC = JNI_TRUE; +#endif // DEBUG + char* cp = PR_GetEnv("CLASSPATH"); + char* p = new char[strlen(cp) + strlen(vm_args.classpath) + 2]; + strcpy(p, vm_args.classpath); + if (cp) { +#ifdef XP_PC + strcat(p, ";"); +#else + strcat(p, ":"); +#endif + strcat(p, cp); + vm_args.classpath = p; + } + +#ifdef DISABLE_JIT + /* workaround to get java dom to work on Linux */ + char **props = new char*[2]; + props[0]="java.compiler="; + props[1]=0; + vm_args.properties = props; +#endif + +#ifdef DEBUG + printf("classpath is \"%s\"\n", vm_args.classpath); +#endif // DEBUG +#ifdef XP_PC + jint rv = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); +#else + jint rv = JNI_CreateJavaVM(&jvm, &env, &vm_args); +#endif + if (rv < 0) { + printf("\n JAVA DOM: could not start jvm\n"); + } else { + printf("\n JAVA DOM: successfully started jvm\n"); + } + delete[] p; +} +#endif /* JAVA_DOM_OJI_ENABLE */ + + +#if defined(DEBUG) +static void dump_document(nsIDOMDocument* domDoc, const char* urlSpec) +{ + if (!domDoc) return; + + if (strstr(urlSpec, ".xul") || + strstr(urlSpec, ".js") || + strstr(urlSpec, ".css") || + strstr(urlSpec, "file:")) return; + + FILE* of = fopen("dom-cpp.txt", "a"); + if (!of) { + perror("nsJavaDOMImpl::dump_document: failed to open output file\n"); + return; + } + + nsIDOMElement* element = nsnull; + nsresult rv = domDoc->GetDocumentElement(&element); + if (NS_FAILED(rv) || !element) + return; + + (void) element->Normalize(); + + fprintf(of, "\n+++ %s +++\n", urlSpec); + dump_node(of, (nsIDOMNode*) element, 0, PR_FALSE); + fprintf(of, "\n"); + fflush(of); + fclose(of); +} + +static void dump_node(FILE* of, nsIDOMNode* node, int indent, + PRBool isMapNode) +{ + if (!node) return; + + fprintf(of, "\n"); + for (int i=0; i < indent; i++) + fprintf(of, " "); + + nsString name; + nsString value; + PRUint16 type; + + node->GetNodeName(name); + node->GetNodeValue(value); + node->GetNodeType(&type); + + const PRUnichar* cname = name.GetUnicode(); + const PRUnichar* cvalue = value.GetUnicode(); + char* cnorm = strip_whitespace(cvalue, value.Length()); + fprintf(of, "name=\"%s\" type=%s value=\"%s\"", + cname, describe_type(type), cnorm); + delete[] cnorm; + + if (isMapNode) return; + + nsIDOMNamedNodeMap* map = nsnull; + node->GetAttributes(&map); + dump_map(of, map, indent); + + nsIDOMNodeList* children = nsnull; + node->GetChildNodes(&children); + if (!children) return; + + PRUint32 length=0; + children->GetLength(&length); + for (PRUint32 j=0; j < length; j++) { + nsIDOMNode* child = nsnull; + children->Item(j, &child); + dump_node(of, child, indent+2, PR_FALSE); + } +} + +static void dump_map(FILE* of, nsIDOMNamedNodeMap* map, int indent) +{ + if (!map) return; + + fprintf(of, "\n"); + PRUint32 length=0; + map->GetLength(&length); + if (length > 0) { + for (int i=0; i < indent; i++) + fprintf(of, " "); + fprintf(of, "------- start attributes -------"); + } + + for (PRUint32 j=0; j < length; j++) { + nsIDOMNode* node = nsnull; + map->Item(j, &node); + dump_node(of, node, indent, PR_TRUE); + } + + if (length > 0) { + fprintf(of, "\n"); + for (int k=0; k < indent; k++) + fprintf(of, " "); + fprintf(of, "------- end attributes -------"); + } +} + +static char* strip_whitespace(const PRUnichar* input, int length) +{ + if (!input || length < 1) { + char* out = new char[1]; + out[0] = 0; + return out; + } + + char* out = new char[length+1]; + char* op = out; + const PRUnichar* ip = input; + PRUnichar c = ' '; + PRUnichar pc = ' '; + int i = 0; + + for (c = *ip++; i++