bunite-core 0.6.0 → 0.8.1

package/src/native/linux/bunite_linux_appres.cpp

@@ -0,0 +1,173 @@
+#include "bunite_linux_internal.h"
+#include "webview_storage.h"
+
+#include <gio/gio.h>
+
+#include <atomic>
+#include <filesystem>
+#include <optional>
+#include <string>
+
+namespace bunite_linux {
+
+namespace {
+
+std::atomic<bool> g_scheme_registered{false};
+
+void fail(WebKitURISchemeRequest* req, GIOErrorEnum code, const char* msg) {
+  GError* err = g_error_new_literal(G_IO_ERROR, code, msg);
+  webkit_uri_scheme_request_finish_error(req, err);
+  g_error_free(err);
+}
+
+// Reject escapes via symlinks or `..`.
+std::optional<std::filesystem::path> resolveUnderRoot(
+  const std::filesystem::path& root, const std::string& rel
+) {
+  std::error_code ec;
+  auto resolved = std::filesystem::weakly_canonical(root / rel, ec);
+  if (ec) return std::nullopt;
+  auto root_str = root.string();
+  auto resolved_str = resolved.string();
+  if (resolved_str == root_str) return resolved;
+  if (resolved_str.rfind(root_str + "/", 0) != 0) return std::nullopt;
+  return resolved;
+}
+
+// dir → /index.html; missing → +".html". Each fallback re-validated under root.
+std::optional<std::filesystem::path> withFallback(
+  const std::filesystem::path& root, const std::filesystem::path& candidate
+) {
+  std::error_code ec;
+  if (std::filesystem::is_regular_file(candidate, ec)) return candidate;
+  if (std::filesystem::is_directory(candidate, ec)) {
+    auto rel = std::filesystem::relative(candidate, root).string();
+    auto idx = resolveUnderRoot(root, rel + "/index.html");
+    if (idx && std::filesystem::is_regular_file(*idx, ec)) return idx;
+  }
+  auto rel = std::filesystem::relative(candidate, root).string();
+  auto withExt = resolveUnderRoot(root, rel + ".html");
+  if (withExt && std::filesystem::is_regular_file(*withExt, ec)) return withExt;
+  return std::nullopt;
+}
+
+bool hasUnsafeSegment(const std::string& path) {
+  size_t pos = 0;
+  while (pos <= path.size()) {
+    size_t next = path.find('/', pos);
+    std::string seg = path.substr(pos, next == std::string::npos ? std::string::npos : next - pos);
+    if (seg == "." || seg == "..") return true;
+    if (seg.find('\\') != std::string::npos) return true;
+    if (next == std::string::npos) break;
+    pos = next + 1;
+  }
+  return false;
+}
+
+std::string mimeFor(const std::filesystem::path& path) {
+  gchar* content_type = g_content_type_guess(path.string().c_str(), nullptr, 0, nullptr);
+  if (!content_type) return "application/octet-stream";
+  gchar* mime = g_content_type_get_mime_type(content_type);
+  std::string out = mime ? mime : "application/octet-stream";
+  g_free(content_type);
+  g_free(mime);
+  return out;
+}
+
+void on_appres_request(WebKitURISchemeRequest* req, gpointer user_data) {
+  (void)user_data;
+  WebKitWebView* wv = webkit_uri_scheme_request_get_web_view(req);
+  const uint32_t view_id = viewIdForWebView(wv);
+  const char* uri_c = webkit_uri_scheme_request_get_uri(req);
+  if (!uri_c) { fail(req, G_IO_ERROR_INVALID_FILENAME, "Empty URI"); return; }
+
+  std::string uri = uri_c;
+  auto prefix_end = uri.find("://");
+  if (prefix_end == std::string::npos) {
+    fail(req, G_IO_ERROR_INVALID_FILENAME, "Invalid URI"); return;
+  }
+  auto rest = uri.substr(prefix_end + 3);
+  auto first_slash = rest.find('/');
+  std::string host = (first_slash == std::string::npos) ? rest : rest.substr(0, first_slash);
+  std::string path = (first_slash == std::string::npos) ? "" : rest.substr(first_slash + 1);
+
+  if (host != "app.internal") {
+    fail(req, G_IO_ERROR_INVALID_ARGUMENT, "Invalid appres host"); return;
+  }
+
+  for (char c : {'?', '#'}) {
+    auto pos = path.find(c);
+    if (pos != std::string::npos) path = path.substr(0, pos);
+  }
+  if (gchar* decoded = g_uri_unescape_string(path.c_str(), nullptr)) {
+    path = decoded;
+    g_free(decoded);
+  } else {
+    fail(req, G_IO_ERROR_INVALID_FILENAME, "Invalid percent-encoding"); return;
+  }
+  if (path.find('\0') != std::string::npos) {
+    fail(req, G_IO_ERROR_INVALID_FILENAME, "NUL in path"); return;
+  }
+  while (!path.empty() && path.back() == '/') path.pop_back();
+  if (path.empty()) path = "index.html";
+
+  if (hasUnsafeSegment(path)) {
+    fail(req, G_IO_ERROR_INVALID_FILENAME, "Unsafe path segment"); return;
+  }
+
+  if (path == "internal/index.html" && bunite::WebviewContentStorage::instance().has(view_id)) {
+    std::string stored = bunite::WebviewContentStorage::instance().get(view_id);
+    GInputStream* stream = g_memory_input_stream_new_from_data(
+      g_memdup2(stored.data(), stored.size()), (gssize)stored.size(), g_free);
+    webkit_uri_scheme_request_finish(req, stream, (gint64)stored.size(), "text/html");
+    g_object_unref(stream);
+    return;
+  }
+
+  if (bunite::AppResRouteStorage::instance().hasRoute(path)) {
+    uint32_t request_id = g_runtime.next_route_request_id++;
+    g_object_ref(req);
+    g_runtime.pending_route_tasks[request_id] = { view_id, req };
+    std::string payload = "{\"requestId\":" + std::to_string(request_id) +
+      ",\"path\":\"" + escapeJsonString(path) + "\"}";
+    emitWebviewEvent(view_id, "route-request", payload);
+    return;
+  }
+
+  auto* state = findView(view_id);
+  if (!state || state->appres_root.empty()) {
+    fail(req, G_IO_ERROR_NOT_FOUND, "appres root not configured"); return;
+  }
+
+  std::error_code ec;
+  auto root = std::filesystem::weakly_canonical(std::filesystem::path(state->appres_root), ec);
+  if (ec) { fail(req, G_IO_ERROR_NOT_FOUND, "Bad appres root"); return; }
+
+  auto candidate = resolveUnderRoot(root, path);
+  if (!candidate) { fail(req, G_IO_ERROR_NOT_FOUND, "Path escapes root"); return; }
+  auto resolved = withFallback(root, *candidate);
+  if (!resolved) { fail(req, G_IO_ERROR_NOT_FOUND, "File not found"); return; }
+
+  gchar* contents = nullptr;
+  gsize length = 0;
+  GError* err = nullptr;
+  if (!g_file_get_contents(resolved->string().c_str(), &contents, &length, &err)) {
+    webkit_uri_scheme_request_finish_error(req, err);
+    g_error_free(err);
+    return;
+  }
+
+  GInputStream* stream = g_memory_input_stream_new_from_data(contents, (gssize)length, g_free);
+  std::string mime = mimeFor(*resolved);
+  webkit_uri_scheme_request_finish(req, stream, (gint64)length, mime.c_str());
+  g_object_unref(stream);
+}
+
+}  // namespace
+
+void registerAppresScheme(WebKitWebContext* ctx) {
+  if (g_scheme_registered.exchange(true)) return;
+  webkit_web_context_register_uri_scheme(ctx, "appres", on_appres_request, nullptr, nullptr);
+}
+
+}  // namespace bunite_linux

package/src/native/linux/bunite_linux_ffi.cpp

@@ -0,0 +1,263 @@
+#include "bunite_linux_internal.h"
+#include "webview_storage.h"
+
+#include <cstdlib>
+#include <cstring>
+#include <mutex>
+#include <string>
+
+using bunite_linux::g_runtime;
+using bunite_linux::runOnUiThreadSync;
+
+#define BUNITE_LINUX_TODO(name)                                                        \
+  do {                                                                                 \
+    static std::once_flag once;                                                        \
+    std::call_once(once, []() {                                                        \
+      BUNITE_WARN("%s not implemented yet on linux (skeleton stub)", name);            \
+    });                                                                                \
+  } while (0)
+
+extern "C" BUNITE_EXPORT bool bunite_window_create(
+  uint32_t window_id, double x, double y, double width, double height,
+  const char* title, const char* title_bar_style,
+  bool transparent, bool hidden, bool minimized, bool maximized
+) {
+  return runOnUiThreadSync([=]() -> bool {
+    return bunite_linux::createWindow(window_id, x, y, width, height, title, title_bar_style,
+                                      transparent, hidden, minimized, maximized);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_destroy(uint32_t window_id) {
+  runOnUiThreadSync([=]() { bunite_linux::destroyWindow(window_id); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_reset_close_pending(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    if (auto* s = bunite_linux::findWindow(window_id)) s->close_pending.store(false);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_show(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    if (auto* s = bunite_linux::findWindow(window_id)) gtk_window_present(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_close(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    if (auto* s = bunite_linux::findWindow(window_id)) gtk_window_close(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_set_title(uint32_t window_id, const char* title) {
+  std::string t = title ? title : "";
+  runOnUiThreadSync([=]() {
+    if (auto* s = bunite_linux::findWindow(window_id)) gtk_window_set_title(s->window, t.c_str());
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_minimize(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    auto* s = bunite_linux::findWindow(window_id);
+    if (s && !s->minimized.exchange(true)) gtk_window_minimize(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_unminimize(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    auto* s = bunite_linux::findWindow(window_id);
+    // GTK4 has no unminimize — present() raises and de-minimizes.
+    if (s && s->minimized.exchange(false)) gtk_window_present(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT bool bunite_window_is_minimized(uint32_t window_id) {
+  return runOnUiThreadSync([=]() -> bool {
+    auto* s = bunite_linux::findWindow(window_id);
+    return s ? s->minimized.load() : false;
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_maximize(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    auto* s = bunite_linux::findWindow(window_id);
+    if (s && !s->maximized.exchange(true)) gtk_window_maximize(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_unmaximize(uint32_t window_id) {
+  runOnUiThreadSync([=]() {
+    auto* s = bunite_linux::findWindow(window_id);
+    if (s && s->maximized.exchange(false)) gtk_window_unmaximize(s->window);
+  });
+}
+
+extern "C" BUNITE_EXPORT bool bunite_window_is_maximized(uint32_t window_id) {
+  return runOnUiThreadSync([=]() -> bool {
+    auto* s = bunite_linux::findWindow(window_id);
+    return s ? s->maximized.load() : false;
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_window_set_frame(
+  uint32_t window_id, double x, double y, double width, double height
+) {
+  (void)x; (void)y;
+  runOnUiThreadSync([=]() {
+    if (auto* s = bunite_linux::findWindow(window_id))
+      gtk_window_set_default_size(s->window, (int)width, (int)height);
+  });
+}
+
+extern "C" BUNITE_EXPORT bool bunite_view_create(
+  uint32_t view_id, uint32_t window_id,
+  const char* url, const char* html, const char* preload,
+  const char* appres_root, const char* navigation_rules_json,
+  double x, double y, double width, double height,
+  bool auto_resize, bool sandbox, const char* preload_origins_json
+) {
+  (void)sandbox;
+  return runOnUiThreadSync([=]() -> bool {
+    return bunite_linux::createView(view_id, window_id, url, html, preload, appres_root,
+                                    navigation_rules_json, preload_origins_json,
+                                    x, y, width, height, auto_resize);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_execute_javascript(uint32_t view_id, const char* script) {
+  std::string s = script ? script : "";
+  runOnUiThreadSync([=]() {
+    if (auto* v = bunite_linux::findView(view_id))
+      webkit_web_view_evaluate_javascript(v->webview, s.c_str(), -1, nullptr, nullptr, nullptr, nullptr, nullptr);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_load_url(uint32_t view_id, const char* url) {
+  std::string s = url ? url : "";
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_linux::findView(view_id);
+    if (!v) return;
+    bunite::WebviewContentStorage::instance().remove(view_id);
+    webkit_web_view_load_uri(v->webview, s.c_str());
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_load_html(uint32_t view_id, const char* html) {
+  std::string content = html ? html : "";
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_linux::findView(view_id);
+    if (!v) return;
+    bunite::WebviewContentStorage::instance().set(view_id, content);
+    webkit_web_view_load_uri(v->webview, "appres://app.internal/internal/index.html");
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_register_appres_route(const char* path) {
+  bunite::AppResRouteStorage::instance().registerRoute(path ? path : "");
+}
+
+extern "C" BUNITE_EXPORT void bunite_unregister_appres_route(const char* path) {
+  bunite::AppResRouteStorage::instance().unregisterRoute(path ? path : "");
+}
+
+extern "C" BUNITE_EXPORT void bunite_complete_route_request(uint32_t request_id, const char* html) {
+  std::string body = html ? html : "";
+  runOnUiThreadSync([=]() {
+    auto it = bunite_linux::g_runtime.pending_route_tasks.find(request_id);
+    if (it == bunite_linux::g_runtime.pending_route_tasks.end()) return;
+    WebKitURISchemeRequest* req = it->second.request;
+    bunite_linux::g_runtime.pending_route_tasks.erase(it);
+    GInputStream* stream = g_memory_input_stream_new_from_data(
+      g_memdup2(body.data(), body.size()), (gssize)body.size(), g_free);
+    webkit_uri_scheme_request_finish(req, stream, (gint64)body.size(), "text/html");
+    g_object_unref(stream);
+    g_object_unref(req);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_visible(uint32_t view_id, bool visible) {
+  runOnUiThreadSync([=]() {
+    if (auto* v = bunite_linux::findView(view_id)) {
+      gtk_widget_set_visible(v->container ? v->container : GTK_WIDGET(v->webview), visible);
+      if (visible) bunite_linux::queueViewRedraw(v->webview);
+    }
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_input_passthrough(uint32_t view_id, bool passthrough) {
+  runOnUiThreadSync([=]() {
+    if (auto* v = bunite_linux::findView(view_id))
+      gtk_widget_set_can_target(GTK_WIDGET(v->webview), !passthrough);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_mask_region(uint32_t view_id, const double* rects, uint32_t count) {
+  // GTK4 has no per-widget region cull primitive — mask not implemented.
+  (void)view_id; (void)rects; (void)count; BUNITE_LINUX_TODO("bunite_view_set_mask_region");
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_bring_to_front(uint32_t view_id) {
+  runOnUiThreadSync([=]() {
+    auto* v = bunite_linux::findView(view_id);
+    if (!v) return;
+    // GtkOverlay handles z-order; reparenting blanks child surfaces under WSLg.
+    bunite_linux::queueViewRedraw(v->webview);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_bounds(
+  uint32_t view_id, double x, double y, double width, double height
+) {
+  runOnUiThreadSync([=]() { bunite_linux::applyViewBounds(view_id, x, y, width, height); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_bounds_async(
+  uint32_t view_id, double x, double y, double width, double height
+) {
+  auto* invoke = new std::function<void()>(
+    [=]() { bunite_linux::applyViewBounds(view_id, x, y, width, height); });
+  g_main_context_invoke_full(g_runtime.ui_context, G_PRIORITY_DEFAULT,
+    +[](gpointer data) -> gboolean {
+      (*static_cast<std::function<void()>*>(data))();
+      return G_SOURCE_REMOVE;
+    },
+    invoke,
+    +[](gpointer data) { delete static_cast<std::function<void()>*>(data); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_set_anchor(uint32_t view_id, int mode, double inset) {
+  (void)view_id; (void)mode; (void)inset; BUNITE_LINUX_TODO("bunite_view_set_anchor");
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_go_back(uint32_t view_id) {
+  runOnUiThreadSync([=]() {
+    if (auto* v = bunite_linux::findView(view_id)) webkit_web_view_go_back(v->webview);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_reload(uint32_t view_id) {
+  runOnUiThreadSync([=]() {
+    if (auto* v = bunite_linux::findView(view_id)) webkit_web_view_reload(v->webview);
+  });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_remove(uint32_t view_id) {
+  runOnUiThreadSync([=]() { bunite_linux::removeView(view_id); });
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id) {
+  (void)view_id; BUNITE_LINUX_TODO("bunite_view_open_devtools");
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_close_devtools(uint32_t view_id) {
+  (void)view_id; BUNITE_LINUX_TODO("bunite_view_close_devtools");
+}
+
+extern "C" BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id) {
+  (void)view_id; BUNITE_LINUX_TODO("bunite_view_toggle_devtools");
+}
+
+extern "C" BUNITE_EXPORT void bunite_complete_permission_request(uint32_t request_id, uint32_t state) {
+  (void)request_id; (void)state; BUNITE_LINUX_TODO("bunite_complete_permission_request");
+}

package/src/native/linux/bunite_linux_internal.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "callbacks.h"
+#include "ffi_exports.h"
+#include "log.h"
+#include "permissions.h"
+
+#include <gtk/gtk.h>
+#include <webkit/webkit.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <functional>
+#include <mutex>
+#include <pthread.h>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace bunite_linux {
+
+struct WindowState {
+  GtkWindow* window = nullptr;
+  // gtk_window_set_child takes one widget — overlay holds main view + surfaces.
+  GtkOverlay* host = nullptr;
+  std::atomic<bool> close_pending{false};
+  // GTK4 lacks is_minimized; is_maximized lies on WSLg/tiling WMs. Track logically.
+  std::atomic<bool> minimized{false};
+  std::atomic<bool> maximized{false};
+};
+
+struct ViewState {
+  GtkWidget* container = nullptr;
+  WebKitWebView* webview = nullptr;
+  uint32_t window_id = 0;
+  std::string appres_root;
+  std::string preload_script;
+  std::string stored_html;
+  std::vector<std::string> navigation_rules;
+};
+
+struct RuntimeState {
+  std::mutex object_mutex;
+  std::unordered_map<uint32_t, WindowState> windows;
+  std::unordered_map<uint32_t, ViewState> views;
+
+  bool initialized = false;
+  bool popup_blocking = false;
+  std::atomic<bool> shutting_down{false};
+
+  GtkApplication* app = nullptr;
+  GMainContext* ui_context = nullptr;
+  pthread_t ui_thread = 0;
+  bool ui_thread_set = false;
+
+  std::unordered_map<uint32_t, WebKitPermissionRequest*> pending_permissions;
+  uint32_t next_permission_request_id = 1;
+
+  struct PendingRoute { uint32_t view_id; WebKitURISchemeRequest* request; };
+  std::unordered_map<uint32_t, PendingRoute> pending_route_tasks;
+  uint32_t next_route_request_id = 1;
+
+  BuniteWebviewEventHandler webview_event_handler = nullptr;
+  BuniteWindowEventHandler window_event_handler = nullptr;
+};
+
+extern RuntimeState g_runtime;
+
+bool isOnMainThread();
+
+template <typename Block>
+auto runOnUiThreadSync(Block block) -> decltype(block()) {
+  using R = decltype(block());
+  if (isOnMainThread()) return block();
+  if constexpr (std::is_void_v<R>) {
+    std::mutex m;
+    std::condition_variable cv;
+    bool done = false;
+    auto invoke = [&]() {
+      block();
+      {
+        std::lock_guard<std::mutex> lock(m);
+        done = true;
+      }
+      cv.notify_all();
+    };
+    auto trampoline = +[](gpointer data) -> gboolean {
+      (*static_cast<decltype(invoke)*>(data))();
+      return G_SOURCE_REMOVE;
+    };
+    g_main_context_invoke_full(g_runtime.ui_context, G_PRIORITY_DEFAULT, trampoline, &invoke, nullptr);
+    std::unique_lock<std::mutex> lock(m);
+    cv.wait(lock, [&]() { return done; });
+  } else {
+    R result{};
+    std::mutex m;
+    std::condition_variable cv;
+    bool done = false;
+    auto invoke = [&]() {
+      result = block();
+      {
+        std::lock_guard<std::mutex> lock(m);
+        done = true;
+      }
+      cv.notify_all();
+    };
+    auto trampoline = +[](gpointer data) -> gboolean {
+      (*static_cast<decltype(invoke)*>(data))();
+      return G_SOURCE_REMOVE;
+    };
+    g_main_context_invoke_full(g_runtime.ui_context, G_PRIORITY_DEFAULT, trampoline, &invoke, nullptr);
+    std::unique_lock<std::mutex> lock(m);
+    cv.wait(lock, [&]() { return done; });
+    return result;
+  }
+}
+
+std::string escapeJsonString(const std::string& value);
+
+void emitWindowEvent(uint32_t window_id, const char* event_name, const std::string& payload = {});
+void emitWebviewEvent(uint32_t view_id, const char* event_name, const std::string& payload = {});
+
+bool globMatchCaseInsensitive(const std::string& pattern, const std::string& value);
+std::vector<std::string> parseNavigationRulesJson(const std::string& json);
+bool shouldAlwaysAllowNavigationUrl(const std::string& url);
+bool shouldAllowNavigation(const ViewState* view, const std::string& url);
+
+WindowState* findWindow(uint32_t window_id);
+bool createWindow(uint32_t window_id, double x, double y, double width, double height,
+                  const char* title, const char* title_bar_style,
+                  bool transparent, bool hidden, bool minimized, bool maximized);
+void destroyWindow(uint32_t window_id);
+
+ViewState* findView(uint32_t view_id);
+uint32_t viewIdForWebView(WebKitWebView* wv);
+bool createView(uint32_t view_id, uint32_t window_id,
+                const char* url, const char* html, const char* preload, const char* appres_root,
+                const char* navigation_rules_json, const char* preload_origins_json,
+                double x, double y, double width, double height, bool auto_resize);
+void removeView(uint32_t view_id);
+void detachViewSideState(uint32_t view_id);
+void applyViewBounds(uint32_t view_id, double x, double y, double width, double height);
+void queueViewRedraw(WebKitWebView* wv);
+
+void registerAppresScheme(WebKitWebContext* ctx);
+
+}  // namespace bunite_linux

package/src/native/linux/bunite_linux_preload.cpp

@@ -0,0 +1 @@
+#include "bunite_linux_internal.h"