View-File macro displays empty div for pptx files in full mode

[abrassat]

Describe the bug
When using a view-file macro to display a pptx file, a large empty div is shown, but no slides are shown.
This issue can be easily checked by viewing the Confluence.Macros.ViewFile page, as there is an example pptx included there.

Steps to reproduce
Steps to reproduce the problematic behavior:

1. Add a view-file macro of any pptx file in full mode ({{view-file display="full" name="test.pptx"/}})
2. View the page

Expected behavior
The presentation is displayed in the page.

Actual behavior
A large empty div is shown instead.

Screenshots

Environment (please complete the following information):

• OS: linux mint
• Browser firefox
• XWiki version 16.10.15, 14.10
• App version 1.29.0 (does not reproduce on 1.28.5)

Additional context
Adding an office macro with the same file ({{office reference="test.pptx"/}}) doesn't have issues with the display.

This issue was opened while investigating #697 .
Might be related, but I don't think so: #624 .

[abrassat]

Might be related:
apache/poi#924

[trrenty]

Created a kind of minimal example that can reproduce the issue:

Macro class:

@Component
@Singleton
@Named("test123")
public class TestClass extends AbstractMacro<Object>
{
    @Inject
    private ComponentManager componentManager;

    @Inject
    private BlockAsyncRendererExecutor executor;

    public TestClass()
    {
        super("TestClass");
    }

    @Override
    public boolean supportsInlineMode()
    {
        return false;
    }

    @Override
    public List<Block> execute(Object parameters, String content, MacroTransformationContext context)
        throws MacroExecutionException
    {
        AsyncRendererConfiguration configuration = new AsyncRendererConfiguration();

        Block result = null;

        try {
            TestAsyncRenderer asyncRenderer =
                componentManager.getInstance(TestAsyncRenderer.class);
            asyncRenderer.initialize(this, context);
            result = executor.execute(asyncRenderer, configuration);
        } catch (JobException | RenderingException | ComponentLookupException e) {
            throw new RuntimeException(e);
        }
        return result instanceof CompositeBlock ? result.getChildren() : Collections.singletonList(result);
    }

    public List<Block> internalExecute()
    {
        return Collections.singletonList(new MacroBlock("info", Collections.emptyMap(), "Hello there", false));
    }
}

Async renderer:

@Component(roles = TestAsyncRenderer.class)
public class TestAsyncRenderer extends AbstractBlockAsyncRenderer
{
    private TestClass testClass;

    private MacroTransformationContext context;

    private Syntax targetSyntax;

    public void initialize(TestClass testClass, MacroTransformationContext context)
    {
        this.context = context;
        this.testClass = testClass;
        this.targetSyntax = context.getTransformationContext().getTargetSyntax();
    }

    @Override
    protected Block execute(boolean async, boolean cached) throws RenderingException
    {
        List<Block> result = testClass.internalExecute();
        return new CompositeBlock(result);
    }

    @Override
    public boolean isInline()
    {
        return false;
    }

    @Override
    public Syntax getTargetSyntax()
    {
        return targetSyntax;
    }

    @Override
    public List<String> getId()
    {
        return createId("test", "async", "renderer", RandomUtils.nextInt());
    }

    @Override
    public boolean isAsyncAllowed()
    {
        return true;
    }

    @Override
    public boolean isCacheAllowed()
    {
        return false;
    }
}

The macro will be empty when executed, but with "async=false" it displays correctly.

Im not sure if the issue is with the macro that returns a "MacroBlock", with the async renderer that returns the rendered result or if there is a platform issue with the async renderer executor.

If we render the block in xwiki syntax and parse it manually, we get the blocks returned by the info macro and the render should work correctly. But is this a workaround or does the async rendering not support macro blocks?

[snazare]

related to XWIKI-24007