fs34b: #i117507# serialize_node: do not reach out into the implementation

of the UNO DOM node (which isn't possible anymore), but use the proper
UNO API for serialization

Conflicts:
	forms/source/xforms/submission/serialization_app_xml.cxx
	forms/source/xforms/submission/serialization_app_xml.hxx
	forms/source/xforms/submission/submission_put.cxx

forms/source/xforms/submission/serialization_app_xml.cxx

@@ -30,6 +30,7 @@
 #include "serialization.hxx"
 #include "serialization_app_xml.hxx"
 
+/** === begin UNO includes === **/
 #include <com/sun/star/io/Pipe.hpp>
 #include <com/sun/star/xml/dom/XNode.hpp>
 #include <com/sun/star/xml/dom/XDocument.hpp>
@@ -37,69 +38,98 @@
 #include <com/sun/star/xml/dom/NodeType.hpp>
 #include <com/sun/star/lang/XUnoTunnel.hpp>
 #include <com/sun/star/xml/xpath/XPathObjectType.hpp>
+#include <com/sun/star/xml/sax/XSAXSerializable.hpp>
+#include <com/sun/star/beans/StringPair.hpp>
+#include <com/sun/star/io/XActiveDataSource.hpp>
+#include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
+/** === end UNO includes === **/
 
 #include <tools/diagnose_ex.h>
 #include <comphelper/processfactory.hxx>
 
-#include <libxml/tree.h>
-
+#include <boost/scoped_ptr.hpp>
 #include <limits>
 
+/** === begin UNO using === **/
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::Exception;
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::uno::RuntimeException;
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::UNO_QUERY_THROW;
+using ::com::sun::star::uno::UNO_SET_THROW;
+using ::com::sun::star::xml::dom::XNode;
+using ::com::sun::star::xml::dom::XDocument;
+using ::com::sun::star::xml::sax::XSAXSerializable;
+using ::com::sun::star::beans::StringPair;
+using ::com::sun::star::io::XActiveDataSource;
+using ::com::sun::star::xml::dom::NodeType_DOCUMENT_NODE;
+using ::com::sun::star::xml::dom::NodeType_ELEMENT_NODE;
+using ::com::sun::star::xml::dom::XDocumentBuilder;
+using ::com::sun::star::xml::sax::XDocumentHandler;
+/** === end UNO using === **/
+
 CSerializationAppXML::CSerializationAppXML()
-    : m_aFactory(comphelper::getProcessServiceFactory())
-    , m_aPipe(CSS::io::Pipe::create(comphelper::getProcessComponentContext()))
-{}
+    : m_xFactory(comphelper::getProcessServiceFactory())
+    , m_xBuffer(CSS::io::Pipe::create(comphelper::getProcessComponentContext()))
+{
+}
 
-CSS::uno::Reference< CSS::io::XInputStream >
+Reference< CSS::io::XInputStream >
 CSerializationAppXML::getInputStream()
 {
     // The pipes output is provided through it's
     // XOutputStream interface aspect
-    return CSS::uno::Reference< CSS::io::XInputStream >(m_aPipe, CSS::uno::UNO_QUERY);
+    return Reference< CSS::io::XInputStream >(m_xBuffer, UNO_QUERY);
 }
 
 void
-CSerializationAppXML::serialize_node(const CSS::uno::Reference< CSS::xml::dom::XNode >& rNode)
+CSerializationAppXML::serialize_node(const Reference< XNode >& rNode)
 {
-    CSS::uno::Reference< CSS::xml::dom::XNode > aNode = rNode;
-    if (aNode->getNodeType() == CSS::xml::dom::NodeType_DOCUMENT_NODE)
+    try
     {
-        CSS::uno::Reference< CSS::xml::dom::XDocument > aDoc(rNode, CSS::uno::UNO_QUERY_THROW);
-        aNode = CSS::uno::Reference< CSS::xml::dom::XNode >(aDoc->getDocumentElement(), CSS::uno::UNO_QUERY_THROW);
-    }
-    ENSURE_OR_RETURN_VOID( aNode->getNodeType() == CSS::xml::dom::NodeType_ELEMENT_NODE,
-        "CSerializationAppXML::serialize_node: invalid node type!" );
-
-    // clone the node to a new document and serialize that document
-    CSS::uno::Reference< CSS::lang::XUnoTunnel > xTunnel( aNode, CSS::uno::UNO_QUERY );
-    ENSURE_OR_RETURN_VOID( xTunnel.is(), "CSerializationAppXML::serialize_node: unknown implementation, cannot serialize!" );
+        Reference< XSAXSerializable > xSerializer( rNode, UNO_QUERY );
+        if ( !xSerializer.is() )
+        {
+            // ensure we have a "real" node
+            Reference< XNode > xNode = rNode;
+            if ( xNode->getNodeType() == NodeType_DOCUMENT_NODE )
+            {
+                Reference< XDocument > const xDoc( xNode, UNO_QUERY_THROW );
+                xNode.set( xDoc->getDocumentElement(), UNO_QUERY_THROW );
+            }
+            ENSURE_OR_RETURN_VOID( xNode->getNodeType() == NodeType_ELEMENT_NODE,
+                "CSerializationAppXML::serialize_node: invalid node type!" );
+
+            // create a new document
+            Reference< XDocumentBuilder > const xDocBuilder(
+                m_xFactory->createInstance( "com.sun.star.xml.dom.DocumentBuilder" ), UNO_QUERY_THROW );
+            Reference< XDocument > const xDocument( xDocBuilder->newDocument(), UNO_SET_THROW );
+
+            // copy the to-be-serialized node
+            Reference< XNode > const xImportedNode( xDocument->importNode( xNode, true ), UNO_SET_THROW );
+            xDocument->appendChild( xImportedNode );
+
+            // ask the doc for the serializer
+            xSerializer.set( xDocument, UNO_QUERY );
+        }
 
-    xmlNodePtr aNodePtr = reinterpret_cast< xmlNodePtr >( xTunnel->getSomething(CSS::uno::Sequence< sal_Int8 >()) );
-    ENSURE_OR_RETURN_VOID( aNodePtr != NULL, "CSerializationAppXML::serialize_node: unable to obtain the xmlNodePtr!" );
+        ENSURE_OR_RETURN_VOID( xSerializer.is(),
+            "CSerializationAppXML::serialize_node: no serialization access to the node/document!" );
 
-    xmlDocPtr aDocPtr = xmlNewDoc((xmlChar*)"1.0");
-    ENSURE_OR_RETURN_VOID( aDocPtr != NULL, "CSerializationAppXML::serialize_node: unable to create a temporary doc!" );
+        // create a SAXWriter to take the serialization events, and connect it to our pipe
+        Reference< XDocumentHandler > const xSaxWriter(
+            m_xFactory->createInstance( "com.sun.star.xml.sax.Writer" ), UNO_QUERY_THROW );
+        Reference< XActiveDataSource > const xDataSource( xSaxWriter, UNO_QUERY_THROW );
+        xDataSource->setOutputStream( Reference< CSS::io::XOutputStream >( m_xBuffer, UNO_QUERY_THROW) );
 
-    xmlNodePtr aDocNodePtr = xmlDocCopyNode(aNodePtr, aDocPtr, 1);
-    if (aDocNodePtr != NULL)
+        // do the serialization
+        xSerializer->serialize( xSaxWriter, Sequence< StringPair >() );
+    }
+    catch( const Exception& )
     {
-        xmlAddChild( (xmlNodePtr)aDocPtr, aDocNodePtr );
-
-        xmlChar *buffer = NULL;
-        int size = 0;
-        xmlDocDumpMemory( aDocPtr, &buffer, &size );
-
-        if ( size > ::std::numeric_limits< sal_Int32 >::max() )
-        {
-            OSL_ENSURE( false, "CSerializationAppXML::serialize_node: document too large, doesn't fit into a UNO sequence!" );
-            size = ::std::numeric_limits< sal_Int32 >::max();
-        }
-
-        // write the xml into the pipe through it's XOutputStream interface
-        m_aPipe->writeBytes(CSS::uno::Sequence< sal_Int8 >((sal_Int8*)buffer, size));
-        xmlFree(buffer);
+        DBG_UNHANDLED_EXCEPTION();
     }
-    xmlFreeDoc( aDocPtr );
 }
 
 void
@@ -107,13 +137,13 @@ CSerializationAppXML::serialize()
 {
     if (!m_aFragment.is()) return;
 
-    CSS::uno::Reference< CSS::xml::dom::XNode > cur = m_aFragment->getFirstChild();
+    Reference< XNode > cur = m_aFragment->getFirstChild();
     while (cur.is())
     {
         serialize_node(cur);
         cur = cur->getNextSibling();
     }
-    m_aPipe->closeOutput();
+    m_xBuffer->closeOutput();
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

forms/source/xforms/submission/serialization_app_xml.hxx

@@ -34,12 +34,13 @@
 
 #include "serialization.hxx"
 
+#include <comphelper/componentcontext.hxx>
 
 class CSerializationAppXML : public CSerialization
 {
 private:
-    CSS::uno::Reference< CSS::lang::XMultiServiceFactory > m_aFactory;
-    CSS::uno::Reference< CSS::io::XPipe > m_aPipe;
+    CSS::uno::Reference< CSS::lang::XMultiServiceFactory > m_xFactory;
+    CSS::uno::Reference< CSS::io::XPipe > m_xBuffer;
 
     void serialize_node(const CSS::uno::Reference< CSS::xml::dom::XNode >& aNode);
     void serialize_nodeset();
@@ -48,8 +49,6 @@ public:
     CSerializationAppXML();
 
     virtual void serialize();
-    //    virtual void setSource(const CSS::uno::Reference< CSS::xml::xpath::XXPathObject >& object);
-    //    virtual void setProperties(const CSS::uno::Sequence< CSS::beans::NamedValue >& props);
     virtual CSS::uno::Reference< CSS::io::XInputStream > getInputStream();
 };
 

forms/source/xforms/submission/submission_put.cxx

@@ -34,6 +34,7 @@
 #include "serialization_urlencoded.hxx"
 
 #include <osl/file.hxx>
+#include <comphelper/processfactory.hxx>
 #include <ucbhelper/content.hxx>
 
 using namespace CSS::uno;
@@ -65,11 +66,10 @@ CSubmission::SubmissionResult CSubmissionPut::submit(const CSS::uno::Reference<
         //aContent.closeStream();
 
         // no content as a result of put...
-
-    } catch (const Exception&)
+    }
+    catch ( const Exception& )
     {
-        // XXX
-        OSL_FAIL("Exception during UCB operatration.");
+        OSL_FAIL( "Exception during UCB operation." );
         return UNKNOWN_ERROR;
     }