sw HTML filter: handle embedded ODF content in xhtml/reqif mode

Embedded native data (what we don't parse just carry on) and real OLE2
embedding already worked, this adds the case where the actual content is
ODF, just inside OLE2.

The DOC import/export had support for handleing ODF content inside OLE2,
so reuse that code: add new functions to SvxMSDffManager for import
purposes and reuse SvxMSExportOLEObjects for export purposes.

Change-Id: I0acf65d4bf29af896b8f1dd625e8672050aae350
Reviewed-on: https://gerrit.libreoffice.org/55088Reviewed-by: Miklos Vajna <vmiklos@collabora.co.uk>
Tested-by: Jenkins <ci@libreoffice.org>

embeddedobj/source/inc/oleembobj.hxx

@@ -106,6 +106,10 @@ public:
 
 class OleComponent;
 class OwnView_Impl;
+/**
+ * Represents an OLE object that has native data and we try to let an external
+ * application handle that data.
+ */
 class OleEmbeddedObject : public ::cppu::WeakImplHelper
                         < css::embed::XEmbeddedObject
                         , css::embed::XEmbeddedOleObject

filter/source/msfilter/msdffimp.cxx

@@ -6936,7 +6936,7 @@ const char* GetInternalServerName_Impl( const SvGlobalName& aGlobName )
     return nullptr;
 }
 
-OUString GetFilterNameFromClassID_Impl( const SvGlobalName& aGlobName )
+OUString SvxMSDffManager::GetFilterNameFromClassID( const SvGlobalName& aGlobName )
 {
     if ( aGlobName == SvGlobalName( SO3_SW_OLE_EMBED_CLASSID_60 ) )
         return OUString( "StarOffice XML (Writer)" );
@@ -6977,6 +6977,13 @@ OUString GetFilterNameFromClassID_Impl( const SvGlobalName& aGlobName )
     return OUString();
 }
 
+void SvxMSDffManager::ExtractOwnStream(SotStorage& rSrcStg, SvMemoryStream& rMemStream)
+{
+    tools::SvRef<SotStorageStream> xStr
+        = rSrcStg.OpenSotStream("package_stream", StreamMode::STD_READ);
+    xStr->ReadStream(rMemStream);
+}
+
 css::uno::Reference < css::embed::XEmbeddedObject >  SvxMSDffManager::CheckForConvertToSOObj( sal_uInt32 nConvertFlags,
                         SotStorage& rSrcStg, const uno::Reference < embed::XStorage >& rDestStorage,
                         const Graphic& rGrf,
@@ -7041,8 +7048,7 @@ css::uno::Reference < css::embed::XEmbeddedObject >  SvxMSDffManager::CheckForCo
         if ( pName )
         {
             // TODO/LATER: perhaps we need to retrieve VisArea and Metafile from the storage also
-            tools::SvRef<SotStorageStream> xStr = rSrcStg.OpenSotStream( "package_stream", StreamMode::STD_READ );
-            xStr->ReadStream( *xMemStream );
+            SvxMSDffManager::ExtractOwnStream(rSrcStg, *xMemStream);
         }
         else
         {
@@ -7077,7 +7083,7 @@ css::uno::Reference < css::embed::XEmbeddedObject >  SvxMSDffManager::CheckForCo
             if ( pFilter )
                 aFilterName = pFilter->GetName();
             else
-                aFilterName = GetFilterNameFromClassID_Impl( aStgNm );
+                aFilterName = SvxMSDffManager::GetFilterNameFromClassID( aStgNm );
 
             uno::Sequence<beans::PropertyValue> aMedium(aFilterName.isEmpty() ? 3 : 4);
             aMedium[0].Name = "InputStream";

include/filter/msfilter/msdffimp.hxx

@@ -65,6 +65,7 @@ struct SvxMSDffShapeOrder;
 class SvxMSDffManager;
 class SfxItemSet;
 struct DffObjData;
+class SvGlobalName;
 
 namespace com { namespace sun { namespace star {
     namespace beans { class XPropertySet; }
@@ -735,6 +736,11 @@ public:
         const OUString& rPropertyName
     );
 
+    /// Determines an ODF filter name (if there is one) for aGlobName.
+    static OUString GetFilterNameFromClassID(const SvGlobalName& aGlobName);
+    /// Extracts ODF data from rSrcStg.
+    static void ExtractOwnStream(SotStorage& rSrcStg, SvMemoryStream& rMemStream);
+
     void insertShapeId( sal_Int32 nShapeId, SdrObject* pShape );
     void removeShapeId( SdrObject const * pShape );
     SdrObject* getShapeForId( sal_Int32 nShapeId );

sw/qa/extras/htmlexport/data/reqif-ole-odg.xhtml

+<reqif-xhtml:div><reqif-xhtml:p><reqif-xhtml:br/>
+
+</reqif-xhtml:p>
+<reqif-xhtml:p><reqif-xhtml:object data="reqif-ole-odg.ole" type="text/rtf">
+<reqif-xhtml:object data="reqif-ole-odg.png" type="image/png" width="533" height="378"/>
+</reqif-xhtml:object><reqif-xhtml:br/>
+
+</reqif-xhtml:p>
+</reqif-xhtml:div>

sw/qa/extras/htmlexport/htmlexport.cxx

@@ -529,6 +529,21 @@ DECLARE_HTMLEXPORT_ROUNDTRIP_TEST(testReqIfOle2, "reqif-ole2.xhtml")
     // exception of type com.sun.star.io.IOException was thrown.
 }
 
+DECLARE_HTMLEXPORT_ROUNDTRIP_TEST(testReqIfOle2Odg, "reqif-ole-odg.xhtml")
+{
+    uno::Reference<text::XTextEmbeddedObjectsSupplier> xSupplier(mxComponent, uno::UNO_QUERY);
+    uno::Reference<container::XIndexAccess> xObjects(xSupplier->getEmbeddedObjects(),
+                                                     uno::UNO_QUERY);
+    uno::Reference<document::XEmbeddedObjectSupplier> xTextEmbeddedObject(xObjects->getByIndex(0),
+                                                                          uno::UNO_QUERY);
+    uno::Reference<lang::XServiceInfo> xObject(xTextEmbeddedObject->getEmbeddedObject(),
+                                               uno::UNO_QUERY);
+    // This failed, both import and export failed to handle OLE2 that contains
+    // just ODF.
+    CPPUNIT_ASSERT(xObject.is());
+    CPPUNIT_ASSERT(xObject->supportsService("com.sun.star.drawing.DrawingDocument"));
+}
+
 DECLARE_HTMLEXPORT_TEST(testList, "list.html")
 {
     SvStream* pStream = maTempFile.GetStream(StreamMode::READ);

sw/source/filter/html/htmlplug.cxx

@@ -62,6 +62,7 @@
 #include <com/sun/star/frame/XStorable.hpp>
 #include <com/sun/star/embed/ElementModes.hpp>
 #include <com/sun/star/io/XActiveDataStreamer.hpp>
+#include <com/sun/star/embed/XEmbedPersist2.hpp>
 
 #include <comphelper/embeddedobjectcontainer.hxx>
 #include <comphelper/classids.hxx>
@@ -69,6 +70,8 @@
 #include <comphelper/storagehelper.hxx>
 #include <vcl/graphicfilter.hxx>
 #include <unotools/ucbstreamhelper.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <filter/msfilter/msoleexp.hxx>
 
 using namespace com::sun::star;
 
@@ -508,11 +511,23 @@ bool SwHTMLParser::InsertEmbed()
                 aFileStream.Seek(0);
                 if (aHeader == aMagic)
                 {
-                    // OLE2 wrapped in RTF.
-                    if (SwReqIfReader::ExtractOleFromRtf(aFileStream, aMemoryStream))
+                    // OLE2 wrapped in RTF: either own format or real OLE2 embedding.
+                    bool bOwnFormat = false;
+                    if (SwReqIfReader::ExtractOleFromRtf(aFileStream, aMemoryStream, bOwnFormat))
                     {
                         xInStream.set(new utl::OStreamWrapper(aMemoryStream));
+                    }
 
+                    if (bOwnFormat)
+                    {
+                        uno::Sequence<beans::PropertyValue> aMedium = comphelper::InitPropertySequence(
+                            { { "InputStream", uno::makeAny(xInStream) },
+                              { "URL", uno::makeAny(OUString("private:stream")) },
+                              { "DocumentBaseURL", uno::makeAny(m_sBaseURL) } });
+                        xObj = aCnt.InsertEmbeddedObject(aMedium, aName, &m_sBaseURL);
+                    }
+                    else
+                    {
                         // The type is now an OLE2 container, not the original XHTML type.
                         aType = "application/vnd.sun.star.oleobject";
                     }
@@ -523,19 +538,24 @@ bool SwHTMLParser::InsertEmbed()
                 // Non-RTF case.
                 xInStream.set(new utl::OStreamWrapper(aFileStream));
 
-            uno::Reference<io::XStream> xOutStream
-                = xStorage->openStreamElement(aObjName, embed::ElementModes::READWRITE);
-            comphelper::OStorageHelper::CopyInputToOutput(xInStream, xOutStream->getOutputStream());
-
-            if (!aType.isEmpty())
+            if (!xObj.is())
             {
-                // Set media type of the native data.
-                uno::Reference<beans::XPropertySet> xOutStreamProps(xOutStream, uno::UNO_QUERY);
-                if (xOutStreamProps.is())
-                    xOutStreamProps->setPropertyValue("MediaType", uno::makeAny(aType));
+                uno::Reference<io::XStream> xOutStream
+                    = xStorage->openStreamElement(aObjName, embed::ElementModes::READWRITE);
+                if (aFileStream.IsOpen())
+                    comphelper::OStorageHelper::CopyInputToOutput(xInStream,
+                                                                  xOutStream->getOutputStream());
+
+                if (!aType.isEmpty())
+                {
+                    // Set media type of the native data.
+                    uno::Reference<beans::XPropertySet> xOutStreamProps(xOutStream, uno::UNO_QUERY);
+                    if (xOutStreamProps.is())
+                        xOutStreamProps->setPropertyValue("MediaType", uno::makeAny(aType));
+                }
             }
+            xObj = aCnt.GetEmbeddedObject(aObjName);
         }
-        xObj = aCnt.GetEmbeddedObject(aObjName);
     }
 
     SfxItemSet aFrameSet( m_xDoc->GetAttrPool(),
@@ -1451,23 +1471,47 @@ Writer& OutHTML_FrameFormatOLENodeGrf( Writer& rWrt, const SwFrameFormat& rFrame
         OUString aFileType;
         SvFileStream aOutStream(aFileName, StreamMode::WRITE);
         uno::Reference<io::XActiveDataStreamer> xStreamProvider;
+        uno::Reference<embed::XEmbedPersist2> xOwnEmbedded;
         if (xEmbeddedObject.is())
+        {
             xStreamProvider.set(xEmbeddedObject, uno::UNO_QUERY);
+            xOwnEmbedded.set(xEmbeddedObject, uno::UNO_QUERY);
+        }
         if (xStreamProvider.is())
         {
+            // Real OLE2 case: OleEmbeddedObject.
             uno::Reference<io::XInputStream> xStream(xStreamProvider->getStream(), uno::UNO_QUERY);
             if (xStream.is())
             {
                 std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xStream));
                 if (SwReqIfReader::WrapOleInRtf(*pStream, aOutStream))
                 {
-                    // OLE2 is always wrapped in RTF.
+                    // Data always wrapped in RTF.
                     aFileType = "text/rtf";
                 }
             }
         }
+        else if (xOwnEmbedded.is())
+        {
+            // Our own embedded object: OCommonEmbeddedObject.
+            SvxMSExportOLEObjects aOLEExp(0);
+            // Trigger the load of the OLE object if needed, otherwise we can't
+            // export it.
+            pOLENd->GetTwipSize();
+            SvMemoryStream aMemory;
+            tools::SvRef<SotStorage> pStorage = new SotStorage(aMemory);
+            aOLEExp.ExportOLEObject(rOLEObj.GetObject(), *pStorage);
+            pStorage->Commit();
+            aMemory.Seek(0);
+            if (SwReqIfReader::WrapOleInRtf(aMemory, aOutStream))
+            {
+                // Data always wrapped in RTF.
+                aFileType = "text/rtf";
+            }
+        }
         else
         {
+            // Otherwise the native data is just a grab-bag: ODummyEmbeddedObject.
             OUString aStreamName = rOLEObj.GetCurrentPersistName();
             uno::Reference<embed::XStorage> xStorage = pDocSh->GetStorage();
             uno::Reference<io::XStream> xInStream

sw/source/filter/html/htmlreqifreader.cxx

@@ -17,6 +17,7 @@
 #include <svtools/rtfkeywd.hxx>
 #include <svtools/rtftoken.h>
 #include <tools/stream.hxx>
+#include <filter/msfilter/msdffimp.hxx>
 
 namespace
 {
@@ -109,9 +110,12 @@ OString InsertOLE1Header(SvStream& rOle2, SvStream& rOle1)
 
     // ClassName
     rOle1.WriteUInt32(aClassName.getLength());
-    rOle1.WriteOString(aClassName);
-    // Null terminated pascal string.
-    rOle1.WriteChar(0);
+    if (!aClassName.isEmpty())
+    {
+        rOle1.WriteOString(aClassName);
+        // Null terminated pascal string.
+        rOle1.WriteChar(0);
+    }
 
     // TopicName.
     rOle1.WriteUInt32(0);
@@ -133,7 +137,7 @@ OString InsertOLE1Header(SvStream& rOle2, SvStream& rOle1)
 
 namespace SwReqIfReader
 {
-bool ExtractOleFromRtf(SvStream& rRtf, SvStream& rOle)
+bool ExtractOleFromRtf(SvStream& rRtf, SvStream& rOle, bool& bOwnFormat)
 {
     // Add missing header/footer.
     SvMemoryStream aRtf;
@@ -149,7 +153,29 @@ bool ExtractOleFromRtf(SvStream& rRtf, SvStream& rOle)
         return false;
 
     // Write the OLE2 data.
-    return xReader->WriteObjectData(rOle);
+    if (!xReader->WriteObjectData(rOle))
+        return false;
+
+    tools::SvRef<SotStorage> pStorage = new SotStorage(rOle);
+    OUString aFilterName = SvxMSDffManager::GetFilterNameFromClassID(pStorage->GetClassName());
+    bOwnFormat = !aFilterName.isEmpty();
+    if (!bOwnFormat)
+    {
+        // Real OLE2 data, we're done.
+        rOle.Seek(0);
+        return true;
+    }
+
+    // ODF-in-OLE2 case, extract actual data.
+    SvMemoryStream aMemory;
+    SvxMSDffManager::ExtractOwnStream(*pStorage, aMemory);
+    rOle.Seek(0);
+    aMemory.Seek(0);
+    rOle.WriteStream(aMemory);
+    // Stream length is current position + 1.
+    rOle.SetStreamSize(aMemory.GetSize() + 1);
+    rOle.Seek(0);
+    return true;
 }
 
 bool WrapOleInRtf(SvStream& rOle2, SvStream& rRtf)

sw/source/filter/html/htmlreqifreader.hxx

@@ -13,8 +13,12 @@ class SvStream;
 
 namespace SwReqIfReader
 {
-/// Extracts an OLE2 container binary from an RTF fragment.
-bool ExtractOleFromRtf(SvStream& rRtf, SvStream& rOle);
+/**
+ * Extracts an OLE2 container binary from an RTF fragment.
+ *
+ * @param bOwnFormat if the extracted data has an ODF class ID or not.
+ */
+bool ExtractOleFromRtf(SvStream& rRtf, SvStream& rOle, bool& bOwnFormat);
 
 /// Wraps an OLE2 container binary in an RTF fragment.
 bool WrapOleInRtf(SvStream& rOle, SvStream& rRtf);