@papyrus-sdk/engine-native 0.2.9 → 0.2.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Papyrus Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/android/build.gradle

@@ -38,4 +38,5 @@ dependencies {
   implementation('io.github.oothp:pdfium-android:1.9.5-beta01') {
     exclude group: 'com.android.support'
   }
+  testImplementation 'junit:junit:4.13.2'
 }

package/android/src/main/cpp/CMakeLists.txt

@@ -1,24 +1,45 @@
-cmake_minimum_required(VERSION 3.18.1)
-project(papyrus_text)
-
-add_library(papyrus_text SHARED
-  papyrus_text_search.cpp
-  papyrus_outline.cpp
-)
-
-target_compile_options(papyrus_text PRIVATE -Wall -Werror)
-target_link_options(papyrus_text PRIVATE "-Wl,-z,max-page-size=16384")
-set_target_properties(papyrus_text PROPERTIES
-  CXX_STANDARD 17
-  CXX_STANDARD_REQUIRED YES
-)
-
-find_library(log-lib log)
-find_library(android-lib android)
-find_library(dl-lib dl)
-
-target_link_libraries(papyrus_text
-  ${log-lib}
-  ${android-lib}
-  ${dl-lib}
-)
+cmake_minimum_required(VERSION 3.18.1)
+project(papyrus_text)
+
+option(PAPYRUS_OUTLINE_HOST_TESTS "Build host tests for the outline loader" OFF)
+
+function(papyrus_set_cxx17 target_name)
+  set_target_properties(${target_name} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED YES
+  )
+endfunction()
+
+if(ANDROID)
+  add_library(papyrus_text SHARED
+    papyrus_text_search.cpp
+    papyrus_outline.cpp
+    papyrus_outline_loader.cpp
+  )
+
+  papyrus_set_cxx17(papyrus_text)
+  target_compile_options(papyrus_text PRIVATE -Wall -Werror)
+  target_link_options(papyrus_text PRIVATE "-Wl,-z,max-page-size=16384")
+
+  find_library(log-lib log)
+  find_library(android-lib android)
+  find_library(dl-lib dl)
+
+  target_link_libraries(papyrus_text
+    ${log-lib}
+    ${android-lib}
+    ${dl-lib}
+  )
+endif()
+
+if(PAPYRUS_OUTLINE_HOST_TESTS)
+  enable_testing()
+
+  add_executable(papyrus_outline_loader_test
+    papyrus_outline_loader.cpp
+    papyrus_outline_loader_test.cpp
+  )
+
+  papyrus_set_cxx17(papyrus_outline_loader_test)
+  add_test(NAME papyrus_outline_loader_test COMMAND papyrus_outline_loader_test)
+endif()

package/android/src/main/cpp/papyrus_outline.cpp

@@ -1,139 +1,173 @@
-#include <jni.h>
-#include <android/log.h>
-#include <dlfcn.h>
-
-#include <algorithm>
-#include <string>
-#include <vector>
-
-#define LOG_TAG "PapyrusOutline"
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
-
-typedef void *FPDF_DOCUMENT;
-typedef void *FPDF_BOOKMARK;
-typedef void *FPDF_DEST;
-
-struct PdfiumFns {
-  FPDF_DOCUMENT (*loadDocument)(const char *, const char *);
-  void (*closeDocument)(FPDF_DOCUMENT);
-  FPDF_BOOKMARK (*bookmarkGetFirstChild)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  FPDF_BOOKMARK (*bookmarkGetNextSibling)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  unsigned long (*bookmarkGetTitle)(FPDF_BOOKMARK, void *, unsigned long);
-  FPDF_DEST (*bookmarkGetDest)(FPDF_DOCUMENT, FPDF_BOOKMARK);
-  int (*destGetPageIndex)(FPDF_DOCUMENT, FPDF_DEST);
-};
-
-static void *g_pdfium = nullptr;
-static PdfiumFns g_fns = {};
-static bool g_loaded = false;
-
-static bool LoadPdfium() {
-  if (g_loaded) return g_pdfium != nullptr;
-
-  g_pdfium = dlopen("libmodpdfium.so", RTLD_LAZY);
-  if (!g_pdfium) {
-    LOGE("Failed to load libmodpdfium.so");
-    g_loaded = true;
-    return false;
-  }
-
-  g_fns.loadDocument = reinterpret_cast<FPDF_DOCUMENT (*)(const char *, const char *)>(dlsym(g_pdfium, "FPDF_LoadDocument"));
-  g_fns.closeDocument = reinterpret_cast<void (*)(FPDF_DOCUMENT)>(dlsym(g_pdfium, "FPDF_CloseDocument"));
-  g_fns.bookmarkGetFirstChild = reinterpret_cast<FPDF_BOOKMARK (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetFirstChild"));
-  g_fns.bookmarkGetNextSibling = reinterpret_cast<FPDF_BOOKMARK (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetNextSibling"));
-  g_fns.bookmarkGetTitle = reinterpret_cast<unsigned long (*)(FPDF_BOOKMARK, void *, unsigned long)>(dlsym(g_pdfium, "FPDFBookmark_GetTitle"));
-  g_fns.bookmarkGetDest = reinterpret_cast<FPDF_DEST (*)(FPDF_DOCUMENT, FPDF_BOOKMARK)>(dlsym(g_pdfium, "FPDFBookmark_GetDest"));
-  g_fns.destGetPageIndex = reinterpret_cast<int (*)(FPDF_DOCUMENT, FPDF_DEST)>(dlsym(g_pdfium, "FPDFDest_GetPageIndex"));
-
-  if (!g_fns.loadDocument || !g_fns.closeDocument || !g_fns.bookmarkGetFirstChild ||
-      !g_fns.bookmarkGetNextSibling || !g_fns.bookmarkGetTitle || !g_fns.bookmarkGetDest ||
-      !g_fns.destGetPageIndex) {
-    LOGE("Failed to load required PDFium symbols for outline");
-    g_loaded = true;
-    return false;
-  }
-
-  g_loaded = true;
-  return true;
-}
-
-static jstring GetBookmarkTitle(JNIEnv *env, FPDF_BOOKMARK bookmark) {
-  unsigned long length = g_fns.bookmarkGetTitle(bookmark, nullptr, 0);
-  if (length <= 2) {
-    return env->NewStringUTF("");
-  }
-
-  std::vector<unsigned short> buffer((length / 2) + 1, 0);
-  unsigned long written = g_fns.bookmarkGetTitle(bookmark, buffer.data(), length);
-  int chars = written > 0 ? static_cast<int>(written / 2) - 1 : static_cast<int>(length / 2) - 1;
-  if (chars <= 0) {
-    return env->NewStringUTF("");
-  }
-
-  return env->NewString(reinterpret_cast<const jchar *>(buffer.data()), chars);
-}
-
-static jobjectArray BuildOutlineItems(JNIEnv *env, FPDF_DOCUMENT doc, FPDF_BOOKMARK parent, jclass itemClass, jmethodID ctor) {
-  std::vector<jobject> items;
-
-  for (FPDF_BOOKMARK child = g_fns.bookmarkGetFirstChild(doc, parent); child;
-       child = g_fns.bookmarkGetNextSibling(doc, child)) {
-    jstring title = GetBookmarkTitle(env, child);
-    int pageIndex = -1;
-    FPDF_DEST dest = g_fns.bookmarkGetDest(doc, child);
-    if (dest) {
-      pageIndex = g_fns.destGetPageIndex(doc, dest);
-    }
-
-    jobjectArray children = BuildOutlineItems(env, doc, child, itemClass, ctor);
-    jobject item = env->NewObject(itemClass, ctor, title, pageIndex, children);
-
-    if (title) env->DeleteLocalRef(title);
-    if (children) env->DeleteLocalRef(children);
-
-    if (item) {
-      items.push_back(item);
-    }
-  }
-
-  jobjectArray array = env->NewObjectArray(static_cast<jsize>(items.size()), itemClass, nullptr);
-  for (jsize i = 0; i < static_cast<jsize>(items.size()); i++) {
-    env->SetObjectArrayElement(array, i, items[i]);
-  }
-
-  return array;
-}
-
-static jobjectArray BuildOutline(JNIEnv *env, FPDF_DOCUMENT doc) {
-  jclass itemClass = env->FindClass("com/papyrus/engine/PapyrusOutlineItem");
-  if (!itemClass) return nullptr;
-  jmethodID ctor = env->GetMethodID(itemClass, "<init>", "(Ljava/lang/String;I[Lcom/papyrus/engine/PapyrusOutlineItem;)V");
-  if (!ctor) return nullptr;
-  return BuildOutlineItems(env, doc, nullptr, itemClass, ctor);
-}
-
-extern "C" JNIEXPORT jobjectArray JNICALL
-Java_com_papyrus_engine_PapyrusOutline_nativeGetOutline(JNIEnv *env, jclass, jlong docPtr) {
-  if (!LoadPdfium()) return nullptr;
-  if (!docPtr) return nullptr;
-
-  FPDF_DOCUMENT doc = reinterpret_cast<FPDF_DOCUMENT>(docPtr);
-  return BuildOutline(env, doc);
-}
-
-extern "C" JNIEXPORT jobjectArray JNICALL
-Java_com_papyrus_engine_PapyrusOutline_nativeGetOutlineFile(JNIEnv *env, jclass, jstring filePath) {
-  if (!LoadPdfium()) return nullptr;
-  if (!filePath) return nullptr;
-
-  const char *path = env->GetStringUTFChars(filePath, nullptr);
-  if (!path) return nullptr;
-
-  FPDF_DOCUMENT doc = g_fns.loadDocument(path, nullptr);
-  env->ReleaseStringUTFChars(filePath, path);
-  if (!doc) return nullptr;
-
-  jobjectArray result = BuildOutline(env, doc);
-  g_fns.closeDocument(doc);
-  return result;
-}
+#include "papyrus_outline_loader.h"
+
+#include <jni.h>
+#include <android/log.h>
+#include <dlfcn.h>
+
+#include <cstring>
+#include <vector>
+
+#define LOG_TAG "PapyrusOutline"
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+OutlineLoaderState g_outline_loader = {};
+
+void *OutlineDlopen(void *, const char *filename, int flags) {
+  return dlopen(filename, flags);
+}
+
+OutlineLoaderDeps::PdfiumSymbol OutlineDlsym(void *, void *handle, const char *symbol_name) {
+  void *raw_symbol = dlsym(handle, symbol_name);
+  OutlineLoaderDeps::PdfiumSymbol symbol = nullptr;
+  static_assert(sizeof(symbol) == sizeof(raw_symbol),
+                "Expected dlsym results to match function pointer size");
+  std::memcpy(&symbol, &raw_symbol, sizeof(symbol));
+  return symbol;
+}
+
+int OutlineDlclose(void *, void *handle) {
+  return dlclose(handle);
+}
+
+const OutlineLoaderDeps kOutlineLoaderDeps = {
+    nullptr,
+    &OutlineDlopen,
+    &OutlineDlsym,
+    &OutlineDlclose,
+    "libmodpdfium.so",
+    RTLD_LAZY,
+};
+
+bool LoadPdfium() {
+  const OutlineLoadAttemptResult result =
+      EnsureOutlinePdfiumLoaded(&g_outline_loader, &kOutlineLoaderDeps);
+  if (!result.loaded && result.transitioned_to_unsupported) {
+    LOGE("Failed to load required PDFium symbols for outline");
+  }
+  return result.loaded;
+}
+
+PdfiumOutlineFns &OutlineFns() {
+  return g_outline_loader.fns;
+}
+
+jstring GetBookmarkTitle(JNIEnv *env, FPDF_BOOKMARK bookmark) {
+  unsigned long length = OutlineFns().bookmarkGetTitle(bookmark, nullptr, 0);
+  if (length <= 2) {
+    return env->NewStringUTF("");
+  }
+
+  std::vector<unsigned short> buffer((length / 2) + 1, 0);
+  unsigned long written = OutlineFns().bookmarkGetTitle(bookmark, buffer.data(), length);
+  int chars = written > 0 ? static_cast<int>(written / 2) - 1
+                          : static_cast<int>(length / 2) - 1;
+  if (chars <= 0) {
+    return env->NewStringUTF("");
+  }
+
+  return env->NewString(reinterpret_cast<const jchar *>(buffer.data()), chars);
+}
+
+jobjectArray BuildOutlineItems(JNIEnv *env,
+                               FPDF_DOCUMENT doc,
+                               FPDF_BOOKMARK parent,
+                               jclass item_class,
+                               jmethodID ctor) {
+  std::vector<jobject> items;
+
+  for (FPDF_BOOKMARK child = OutlineFns().bookmarkGetFirstChild(doc, parent); child;
+       child = OutlineFns().bookmarkGetNextSibling(doc, child)) {
+    jstring title = GetBookmarkTitle(env, child);
+    int page_index = -1;
+    FPDF_DEST dest = OutlineFns().bookmarkGetDest(doc, child);
+    if (dest != nullptr) {
+      page_index = OutlineFns().destGetPageIndex(doc, dest);
+    }
+
+    jobjectArray children = BuildOutlineItems(env, doc, child, item_class, ctor);
+    jobject item = env->NewObject(item_class, ctor, title, page_index, children);
+
+    if (title != nullptr) {
+      env->DeleteLocalRef(title);
+    }
+    if (children != nullptr) {
+      env->DeleteLocalRef(children);
+    }
+
+    if (item != nullptr) {
+      items.push_back(item);
+    }
+  }
+
+  jobjectArray array =
+      env->NewObjectArray(static_cast<jsize>(items.size()), item_class, nullptr);
+  for (jsize i = 0; i < static_cast<jsize>(items.size()); i++) {
+    env->SetObjectArrayElement(array, i, items[i]);
+  }
+
+  return array;
+}
+
+jobjectArray BuildOutline(JNIEnv *env, FPDF_DOCUMENT doc) {
+  jclass item_class = env->FindClass("com/papyrus/engine/PapyrusOutlineItem");
+  if (item_class == nullptr) {
+    return nullptr;
+  }
+
+  jmethodID ctor = env->GetMethodID(
+      item_class, "<init>", "(Ljava/lang/String;I[Lcom/papyrus/engine/PapyrusOutlineItem;)V");
+  if (ctor == nullptr) {
+    return nullptr;
+  }
+
+  return BuildOutlineItems(env, doc, nullptr, item_class, ctor);
+}
+
+}  // namespace
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_com_papyrus_engine_PapyrusOutline_nativeIsOutlineSupported(JNIEnv *, jclass) {
+  return LoadPdfium() ? JNI_TRUE : JNI_FALSE;
+}
+
+extern "C" JNIEXPORT jobjectArray JNICALL
+Java_com_papyrus_engine_PapyrusOutline_nativeGetOutline(JNIEnv *env, jclass, jlong docPtr) {
+  if (!LoadPdfium()) {
+    return nullptr;
+  }
+  if (!docPtr) {
+    return nullptr;
+  }
+
+  FPDF_DOCUMENT doc = reinterpret_cast<FPDF_DOCUMENT>(docPtr);
+  return BuildOutline(env, doc);
+}
+
+extern "C" JNIEXPORT jobjectArray JNICALL
+Java_com_papyrus_engine_PapyrusOutline_nativeGetOutlineFile(JNIEnv *env,
+                                                            jclass,
+                                                            jstring filePath) {
+  if (!LoadPdfium()) {
+    return nullptr;
+  }
+  if (filePath == nullptr) {
+    return nullptr;
+  }
+
+  const char *path = env->GetStringUTFChars(filePath, nullptr);
+  if (path == nullptr) {
+    return nullptr;
+  }
+
+  FPDF_DOCUMENT doc = OutlineFns().loadDocument(path, nullptr);
+  env->ReleaseStringUTFChars(filePath, path);
+  if (doc == nullptr) {
+    return nullptr;
+  }
+
+  jobjectArray result = BuildOutline(env, doc);
+  OutlineFns().closeDocument(doc);
+  return result;
+}

package/android/src/main/cpp/papyrus_outline_loader.cpp

@@ -0,0 +1,125 @@
+#include "papyrus_outline_loader.h"
+
+#include <cstring>
+
+namespace {
+
+void ClearOutlineFns(PdfiumOutlineFns *fns) {
+  if (fns == nullptr) {
+    return;
+  }
+
+  *fns = {};
+}
+
+void CloseHandleIfPresent(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr || state->handle == nullptr) {
+    return;
+  }
+
+  if (deps != nullptr && deps->dlclose_fn != nullptr) {
+    deps->dlclose_fn(deps->user_data, state->handle);
+  }
+
+  state->handle = nullptr;
+}
+
+void TransitionToUnsupported(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return;
+  }
+
+  ClearOutlineFns(&state->fns);
+  CloseHandleIfPresent(state, deps);
+  state->load_state = OutlineLoadState::kUnsupported;
+}
+
+template <typename FnType>
+FnType ResolveOutlineSymbol(const OutlineLoaderDeps *deps, void *handle, const char *symbol_name) {
+  const OutlineLoaderDeps::PdfiumSymbol raw_symbol =
+      deps->dlsym_fn(deps->user_data, handle, symbol_name);
+
+  FnType resolved_symbol = nullptr;
+  static_assert(sizeof(resolved_symbol) == sizeof(raw_symbol),
+                "Expected function pointers to share the same size");
+  std::memcpy(&resolved_symbol, &raw_symbol, sizeof(resolved_symbol));
+  return resolved_symbol;
+}
+
+PdfiumOutlineFns LoadOutlineFns(void *handle, const OutlineLoaderDeps *deps) {
+  PdfiumOutlineFns fns = {};
+  fns.loadDocument =
+      ResolveOutlineSymbol<decltype(fns.loadDocument)>(deps, handle, "FPDF_LoadDocument");
+  fns.closeDocument =
+      ResolveOutlineSymbol<decltype(fns.closeDocument)>(deps, handle, "FPDF_CloseDocument");
+  fns.bookmarkGetFirstChild = ResolveOutlineSymbol<decltype(fns.bookmarkGetFirstChild)>(
+      deps, handle, "FPDFBookmark_GetFirstChild");
+  fns.bookmarkGetNextSibling = ResolveOutlineSymbol<decltype(fns.bookmarkGetNextSibling)>(
+      deps, handle, "FPDFBookmark_GetNextSibling");
+  fns.bookmarkGetTitle =
+      ResolveOutlineSymbol<decltype(fns.bookmarkGetTitle)>(deps, handle, "FPDFBookmark_GetTitle");
+  fns.bookmarkGetDest =
+      ResolveOutlineSymbol<decltype(fns.bookmarkGetDest)>(deps, handle, "FPDFBookmark_GetDest");
+  fns.destGetPageIndex =
+      ResolveOutlineSymbol<decltype(fns.destGetPageIndex)>(deps, handle, "FPDFDest_GetPageIndex");
+  return fns;
+}
+
+bool HasRequiredDeps(const OutlineLoaderDeps *deps) {
+  return deps != nullptr && deps->dlopen_fn != nullptr && deps->dlsym_fn != nullptr &&
+         deps->dlclose_fn != nullptr && deps->library_name != nullptr;
+}
+
+}  // namespace
+
+bool HasCompleteOutlineFns(const PdfiumOutlineFns &fns) {
+  return fns.loadDocument != nullptr && fns.closeDocument != nullptr &&
+         fns.bookmarkGetFirstChild != nullptr && fns.bookmarkGetNextSibling != nullptr &&
+         fns.bookmarkGetTitle != nullptr && fns.bookmarkGetDest != nullptr &&
+         fns.destGetPageIndex != nullptr;
+}
+
+OutlineLoadAttemptResult EnsureOutlinePdfiumLoaded(OutlineLoaderState *state,
+                                                   const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return {};
+  }
+
+  if (state->load_state == OutlineLoadState::kSupported) {
+    return {true, false};
+  }
+
+  if (state->load_state == OutlineLoadState::kUnsupported) {
+    return {false, false};
+  }
+
+  if (!HasRequiredDeps(deps)) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->handle = deps->dlopen_fn(deps->user_data, deps->library_name, deps->dlopen_flags);
+  if (state->handle == nullptr) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->fns = LoadOutlineFns(state->handle, deps);
+  if (!HasCompleteOutlineFns(state->fns)) {
+    TransitionToUnsupported(state, deps);
+    return {false, true};
+  }
+
+  state->load_state = OutlineLoadState::kSupported;
+  return {true, false};
+}
+
+void ResetOutlineLoaderState(OutlineLoaderState *state, const OutlineLoaderDeps *deps) {
+  if (state == nullptr) {
+    return;
+  }
+
+  ClearOutlineFns(&state->fns);
+  CloseHandleIfPresent(state, deps);
+  state->load_state = OutlineLoadState::kUninitialized;
+}

package/android/src/main/cpp/papyrus_outline_loader.h

@@ -0,0 +1,48 @@
+#pragma once
+
+using FPDF_DOCUMENT = void *;
+using FPDF_BOOKMARK = void *;
+using FPDF_DEST = void *;
+
+enum class OutlineLoadState {
+  kUninitialized,
+  kSupported,
+  kUnsupported,
+};
+
+struct PdfiumOutlineFns {
+  FPDF_DOCUMENT (*loadDocument)(const char *, const char *) = nullptr;
+  void (*closeDocument)(FPDF_DOCUMENT) = nullptr;
+  FPDF_BOOKMARK (*bookmarkGetFirstChild)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  FPDF_BOOKMARK (*bookmarkGetNextSibling)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  unsigned long (*bookmarkGetTitle)(FPDF_BOOKMARK, void *, unsigned long) = nullptr;
+  FPDF_DEST (*bookmarkGetDest)(FPDF_DOCUMENT, FPDF_BOOKMARK) = nullptr;
+  int (*destGetPageIndex)(FPDF_DOCUMENT, FPDF_DEST) = nullptr;
+};
+
+struct OutlineLoaderDeps {
+  using PdfiumSymbol = void (*)();
+
+  void *user_data = nullptr;
+  void *(*dlopen_fn)(void *user_data, const char *filename, int flags) = nullptr;
+  PdfiumSymbol (*dlsym_fn)(void *user_data, void *handle, const char *symbol_name) = nullptr;
+  int (*dlclose_fn)(void *user_data, void *handle) = nullptr;
+  const char *library_name = nullptr;
+  int dlopen_flags = 0;
+};
+
+struct OutlineLoaderState {
+  void *handle = nullptr;
+  PdfiumOutlineFns fns = {};
+  OutlineLoadState load_state = OutlineLoadState::kUninitialized;
+};
+
+struct OutlineLoadAttemptResult {
+  bool loaded = false;
+  bool transitioned_to_unsupported = false;
+};
+
+bool HasCompleteOutlineFns(const PdfiumOutlineFns &fns);
+OutlineLoadAttemptResult EnsureOutlinePdfiumLoaded(OutlineLoaderState *state,
+                                                   const OutlineLoaderDeps *deps);
+void ResetOutlineLoaderState(OutlineLoaderState *state, const OutlineLoaderDeps *deps);