support wasm standalone

Author: paulocoutinhox

docker/android/Dockerfile

@@ -54,7 +54,7 @@ RUN mkdir /build
 WORKDIR /build
 RUN gclient config --custom-var checkout_configuration=minimal --unmanaged https://pdfium.googlesource.com/pdfium.git
 RUN echo "target_os = [ 'android' ]" >> .gclient
-RUN gclient sync -r origin/chromium/7442 --no-history --shallow
+RUN gclient sync -r origin/chromium/7590 --no-history --shallow
 
 # pdfium reset and clean directories
 RUN git -C /build/pdfium reset --hard

docker/wasm/Dockerfile

@@ -38,7 +38,7 @@ RUN mkdir /build
 WORKDIR /build
 RUN gclient config --custom-var checkout_configuration=minimal --unmanaged https://pdfium.googlesource.com/pdfium.git
 RUN echo "target_os = [ 'emscripten' ]" >> .gclient
-RUN gclient sync -r origin/chromium/7442 --no-history --shallow
+RUN gclient sync -r origin/chromium/7590 --no-history --shallow
 
 # pdfium reset and clean directories
 RUN git -C /build/pdfium reset --hard

modules/config.py

@@ -3,8 +3,8 @@
 task = ""
 
 # pdfium
-pdfium_git_branch = "chromium/7442"
-# ^ ref: https://pdfium.googlesource.com/pdfium/+/refs/heads/chromium/7442
+pdfium_git_branch = "chromium/7590"
+# ^ ref: https://pdfium.googlesource.com/pdfium/+/refs/heads/chromium/7590
 # OBS 1: don't forget change in android docker file (docker/android/Dockerfile)
 # OBS 2: don't forget change in wasm docker file (docker/wasm/Dockerfile)
 

modules/wasm.py

@@ -483,64 +483,158 @@ def run_task_test():
 
 # -----------------------------------------------------------------------------
 def run_task_test_wasmtime():
-    import wasmtime
-    from wasmtime import Engine, Func, Instance, Linker, Module, Store
-    from wasmtime.loader import WasiConfig
+    from pathlib import Path
+
+    from wasmtime import Engine, FuncType, Linker, Module, Store, WasiConfig
 
     l.colored("Testing with wasmtime...", l.YELLOW)
 
     current_dir = f.current_dir()
 
-    for target in c.targets_wasm:
-        # paths
-        relative_dir = os.path.join(
-            "build",
-            target["target_os"],
-            target["target_cpu"],
-        )
+    for config in c.configurations_wasm:
+        for target in c.targets_wasm:
+            l.colored(
+                'Testing arch "{0}" and configuration "{1}"...'.format(
+                    target["target_cpu"], config
+                ),
+                l.YELLOW,
+            )
+
+            # paths
+            relative_dir = os.path.join(
+                "build",
+                target["target_os"],
+                target["target_cpu"],
+                config,
+            )
+
+            root_dir = os.path.join(current_dir, relative_dir)
+            node_dir = os.path.join(root_dir, "node")
+            wasm_file = os.path.join(node_dir, "pdfium.std.wasm")
+
+            # check if wasm file exists
+            if not f.file_exists(wasm_file):
+                l.e(f"WASM file not found: {wasm_file}")
+                continue
+
+            l.bullet(f"WASM file: {wasm_file}", l.YELLOW)
+
+            # create engine and load the pdfium.wasm module
+            engine = Engine()
+            module = Module.from_file(engine, wasm_file)
+
+            # create WASI context and store
+            wasi_config = WasiConfig()
+            wasi_config.inherit_stdin()
+            wasi_config.inherit_stdout()
+            wasi_config.inherit_stderr()
+
+            store = Store(engine)
+            store.set_wasi(wasi_config)
+
+            # create a linker and add WASI support
+            linker = Linker(engine)
+            linker.define_wasi()
+
+            # define stub functions for unknown imports
+            for imp in module.imports:
+                module_name = imp.module
+                field_name = imp.name
+
+                # check if this is a function import
+                if isinstance(imp.type, FuncType):
+                    func_type = imp.type
+
+                    # create a stub function that returns default values
+                    def make_stub(ft):
+                        def stub_func(*_args):
+                            # return default values (0 or None) based on results
+                            if ft.results:
+                                if len(ft.results) == 1:
+                                    return 0
+                                return tuple(0 for _ in ft.results)
+                            return None
+
+                        return stub_func
+
+                    try:
+                        linker.define_func(
+                            module_name, field_name, func_type, make_stub(func_type)
+                        )
+                    except Exception:
+                        # already defined (e.g., by WASI)
+                        pass
+
+            # instantiate the module
+            instance = linker.instantiate(store, module)
+            exports = instance.exports(store)
+
+            # get and call FPDF_InitLibrary function
+            try:
+                init_library = exports["FPDF_InitLibrary"]
+                init_library(store)
+                l.bullet("FPDF_InitLibrary successfully called", l.GREEN)
+            except KeyError:
+                l.e("Function 'FPDF_InitLibrary' not found")
+                continue
+
+            # test with a sample PDF file
+            sample_pdf = os.path.join(
+                current_dir, "sample-wasm", "assets", "web-assembly.pdf"
+            )
+
+            if not f.file_exists(sample_pdf):
+                l.bullet("Sample PDF not found, skipping document test", l.PURPLE)
+                continue
+
+            l.bullet(f"Testing with PDF: {sample_pdf}", l.YELLOW)
+
+            # read PDF data
+            pdf_path = Path(sample_pdf)
+            pdf_data = pdf_path.read_bytes()
+
+            # allocate memory for the PDF data
+            malloc = exports["malloc"]
+            memory = exports["memory"]
+
+            # allocate buffer in WASM memory
+            buf_ptr = malloc(store, len(pdf_data))
+            mem_data = memory.data_ptr(store)
+
+            # copy PDF data to WASM memory
+            for i, byte in enumerate(pdf_data):
+                mem_data[buf_ptr + i] = byte
 
-        root_dir = os.path.join(current_dir, relative_dir)
-        gen_dir = os.path.join(root_dir, "gen")
-        gen_out_dir = os.path.join(gen_dir, "out")
-        wasm_file = os.path.join(gen_out_dir, "pdfium.std.wasm")
-
-        # create the engine and store
-        engine = Engine()
-        store = Store(engine)
-
-        # load the WebAssembly module
-        module = Module.from_file(engine, wasm_file)
-
-        # create a linker to provide the necessary imports
-        linker = Linker(engine)
-
-        # WASI support using wasmtime.loader.WasiConfig
-        wasi_config = WasiConfig()
-        wasi_config.inherit_stdin()
-        wasi_config.inherit_stdout()
-        wasi_config.inherit_stderr()
-        store.set_wasi(wasi_config)
-
-        # instantiate the WebAssembly module with linker
-        instance = linker.instantiate(store, module)
-
-        # now we can invoke exported functions from the WebAssembly module
-        try:
-            init_library = instance.exports(store)["FPDF_InitLibrary"]
-            init_library(store)
-            l.i("FPDF_InitLibrary successfully called.")
-        except KeyError:
-            l.e("Function 'FPDF_InitLibrary' not found.")
-
-        # invoke 'FPDF_GetLastError'
-        try:
-            get_last_error = instance.exports(store)["FPDF_GetLastError"]
-            result = get_last_error(store)
-            l.i(f"Result from FPDF_GetLastError: {result}")
-        except KeyError:
-            l.e("Function 'FPDF_GetLastError' not found.")
-
-        l.i(f"Result: {result}")
+            # load the PDF document from memory
+            fpdf_load_mem_document = exports["FPDF_LoadMemDocument"]
+            doc = fpdf_load_mem_document(store, buf_ptr, len(pdf_data), 0)
+
+            if doc == 0:
+                get_last_error = exports["FPDF_GetLastError"]
+                error = get_last_error(store)
+                l.e(f"Failed to load PDF. Error code: {error}")
+
+                # free the allocated memory
+                free = exports["free"]
+                free(store, buf_ptr)
+                continue
+
+            # get page count
+            fpdf_get_page_count = exports["FPDF_GetPageCount"]
+            page_count = fpdf_get_page_count(store, doc)
+
+            l.bullet(f"PDF: {pdf_path.name}", l.GREEN)
+            l.bullet(f"Number of pages: {page_count}", l.GREEN)
+
+            # close the document
+            fpdf_close_document = exports["FPDF_CloseDocument"]
+            fpdf_close_document(store, doc)
+
+            # free the allocated memory
+            free = exports["free"]
+            free(store, buf_ptr)
+
+            l.bullet("Test completed successfully", l.GREEN)
 
     l.ok()
 
@@ -655,7 +749,8 @@ def run_task_generate():
                 "{0}".format("-g" if config == "debug" else "-O2"),
                 "-s",
                 f"EXPORTED_FUNCTIONS={complete_functions_list}",
-                "-s", "ALLOW_TABLE_GROWTH",
+                "-s",
+                "ALLOW_TABLE_GROWTH",
                 "-s",
                 'EXPORTED_RUNTIME_METHODS=\'["ccall", "cwrap", "wasmExports", "HEAP8", "HEAP16", "HEAP32", "HEAPU8", "HEAPU16", "HEAPU32", "HEAPF32", "HEAPF64", "addFunction", "removeFunction", "setValue"]\'',
                 "custom.cpp",
@@ -848,7 +943,9 @@ def run_task_archive():
             )
 
             # Create per config "npm install"-compatible tarball
-            per_config_tar = tarfile.open(os.path.join(current_dir, f"wasm-{config}.tgz"), "w:gz")
+            per_config_tar = tarfile.open(
+                os.path.join(current_dir, f"wasm-{config}.tgz"), "w:gz"
+            )
             per_config_tar.add(
                 name=lib_dir,
                 # Use "package" as the root directory to be compatible with "npm install"