put module sources to a single dir

updated makefiles


git-svn-id: svn://10.0.0.236/trunk@64411 18797224-902f-48f8-a5cc-f745e15eee43

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;
+}
+
+

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();
+};
+

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

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

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

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__ */

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 <stdio.h>
+#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, "<init>", "(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++<length; c = *ip++) {
+    if ((pc == ' ' || pc == '\n' || pc == '\t') &&
+	(c == ' ' || c == '\n' || c == '\t'))
+      continue;
+    *op++ = (char)c;
+    pc = c;
+  }
+  *op++ = 0;
+
+  return out;
+}
+
+static const char* describe_type(int type)
+{
+  switch (type) {
+  case nsIDOMNode::ELEMENT_NODE: return "ELEMENT";
+  case nsIDOMNode::ATTRIBUTE_NODE: return "ATTRIBUTE";
+  case nsIDOMNode::TEXT_NODE: return "TEXT";
+  case nsIDOMNode::CDATA_SECTION_NODE: return "CDATA_SECTION";
+  case nsIDOMNode::ENTITY_REFERENCE_NODE: return "ENTITY_REFERENCE";
+  case nsIDOMNode::ENTITY_NODE: return "ENTITY";
+  case nsIDOMNode::PROCESSING_INSTRUCTION_NODE: return "PROCESSING_INSTRUCTION";
+  case nsIDOMNode::COMMENT_NODE: return "COMMENT";
+  case nsIDOMNode::DOCUMENT_NODE: return "DOCUMENT";
+  case nsIDOMNode::DOCUMENT_TYPE_NODE: return "DOCUMENT_TYPE";
+  case nsIDOMNode::DOCUMENT_FRAGMENT_NODE: return "DOCUMENT_FRAGMENT";
+  case nsIDOMNode::NOTATION_NODE: return "NOTATION";
+  }
+  return "ERROR";
+}
+#endif

mozilla/java/dom/src/nsJavaDOMImpl.h

@@ -0,0 +1,88 @@
+#ifndef __nsJavaDOMImpl_h__
+#define __nsJavaDOMImpl_h__
+
+#include "jni.h"
+#include "nsIJavaDOM.h"
+#ifdef JAVA_DOM_OJI_ENABLE
+#include "nsJVMManager.h"
+#include "JavaDOMSecurityContext.h"
+#endif 
+
+class nsIURI;
+class nsIDOMDocument;
+class nsIDocumentLoader;
+
+class nsJavaDOMImpl : public nsIJavaDOM {
+  NS_DECL_ISUPPORTS
+
+ public:
+  nsJavaDOMImpl();
+  virtual ~nsJavaDOMImpl();
+
+  /* nsIDocumentLoaderObserver methods */
+  NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader, 
+				 nsIURI* aURL, 
+				 const char* aCommand);
+
+  NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader, 
+			       nsIChannel* channel, 
+			       nsresult aStatus);
+
+  NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader, 
+			    nsIChannel* channel); 
+
+  NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader,
+			       nsIChannel* channel, 
+			       PRUint32 aProgress, 
+                               PRUint32 aProgressMax);
+
+  NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader, 
+			     nsIChannel* channel, 
+			     nsString& aMsg);
+
+  NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader, 
+			  nsIChannel* channel, 
+			  nsresult aStatus);
+
+  NS_IMETHOD HandleUnknownContentType(nsIDocumentLoader* loader,
+				      nsIChannel* channel, 
+				      const char *aContentType,
+				      const char *aCommand);
+
+ private:
+#ifdef JAVA_DOM_OJI_ENABLE
+  static nsJVMManager* jvmManager;
+  static JavaDOMSecurityContext* securityContext;
+#else
+  static JavaVM*        jvm;
+#endif
+
+  static jclass		domAccessorClass;
+  static jclass		documentClass;
+  static jclass		listenerClass;
+  static jclass		gcClass;
+
+  static jobject	docListener;
+
+  static jfieldID	documentPtrFID;
+  static jmethodID      documentInitID;
+
+  static jmethodID	getInstanceMID;
+  static jmethodID	startURLLoadMID;
+  static jmethodID	endURLLoadMID;
+  static jmethodID	progressURLLoadMID;
+  static jmethodID	statusURLLoadMID;
+  static jmethodID	startDocumentLoadMID;
+  static jmethodID	endDocumentLoadMID;
+
+  static jmethodID	gcMID;
+
+  // cleanup after a JNI method invocation
+  static PRBool Cleanup(JNIEnv* env);
+  static JNIEnv* GetJNIEnv(void);
+  static void StartJVM(void);
+  nsIDOMDocument* GetDocument(nsIDocumentLoader* loader);  
+  jobject CaffienateDOMDocument(nsIDOMDocument* domDoc);
+};
+
+#endif /* __nsJavaDOMImpl_h__ */