sparkbun 0.1.0

package/src/native/shared/partition_context.h

@@ -0,0 +1,137 @@
+// partition_context.h - Cross-platform CEF partition (CefRequestContext) management.
+//
+// Consumers must already have included CEF headers that define
+// CefRequestContext / CefRequestContextSettings / CefSchemeHandlerFactory
+// (e.g. include/cef_app.h, which pulls them in transitively).
+//
+// Behavior (consistent across macOS, Linux, Windows):
+//   - partition == ""               → fresh ephemeral CefRequestContext per call.
+//     We deliberately do NOT route the default partition to GetGlobalContext():
+//     under Chrome runtime, attaching multiple browsers to the global context in
+//     rapid succession races with Chrome's window-framework code and intermittently
+//     opens the browser in its own top-level chrome window (with URL bar) instead
+//     of honoring the embedder's SetAsChild. A per-webview ephemeral context
+//     sidesteps that race and matches the pre-consolidation Linux/Windows behavior.
+//   - partition starts with "persist:" → cached per identifier; first call creates
+//     a new CefRequestContext with a custom cache_path on disk, subsequent calls
+//     for the same identifier reuse it. Caching is required because CEF's Chrome
+//     runtime refuses to bind two CefRequestContexts to the same on-disk profile,
+//     and prior code crashed when a second webview tried to share a partition.
+//   - any other partition (e.g. "temp:foo") → fresh ephemeral in-memory context
+//     per call, never cached. Closing and reopening a webview that uses
+//     "temp:foo" therefore yields fresh storage.
+//   - if CefRequestContext::CreateContext returns null (some Chrome runtime
+//     configurations refuse custom profile paths), we fall back to the global
+//     context for that partition with a warning. The webview still loads;
+//     isolation is lost for that one partition.
+
+#ifndef ELECTROBUN_PARTITION_CONTEXT_H
+#define ELECTROBUN_PARTITION_CONTEXT_H
+
+#include <string>
+#include <map>
+#include <mutex>
+#include <cstdio>
+
+namespace electrobun {
+
+// Platform-provided. Returns the absolute filesystem cache_path for a
+// persistent partition with the given name (e.g. "test1"), creating any
+// missing parent directories. Returning an empty string causes the caller
+// to fall back to an ephemeral (in-memory) context for that webview.
+std::string buildAndEnsurePartitionCachePath(const std::string& partitionName);
+
+inline std::map<std::string, CefRefPtr<CefRequestContext>>& partitionContextMap_() {
+    static std::map<std::string, CefRefPtr<CefRequestContext>> map;
+    return map;
+}
+
+inline std::mutex& partitionContextMutex_() {
+    static std::mutex m;
+    return m;
+}
+
+// Returns the CefRequestContext to use for a webview with the given partition
+// identifier. Registers `schemeFactory` on every returned context so views://
+// resolves correctly regardless of which context handles the request.
+inline CefRefPtr<CefRequestContext> getOrCreateRequestContextForPartition(
+    const char* partitionIdentifier,
+    uint32_t webviewId,
+    CefRefPtr<CefSchemeHandlerFactory> schemeFactory) {
+
+    std::string identifier(partitionIdentifier ? partitionIdentifier : "");
+
+    auto registerScheme = [&](CefRefPtr<CefRequestContext> ctx) {
+        if (ctx && schemeFactory) {
+            ctx->RegisterSchemeHandlerFactory("views", "", schemeFactory);
+        }
+    };
+
+    bool isPersistent = identifier.size() >= 8 && identifier.compare(0, 8, "persist:") == 0;
+
+    // Default partition → fresh ephemeral context per webview.
+    // Avoids a Chrome-runtime race where multiple browsers attached to the
+    // global context can spawn their own top-level chrome window instead of
+    // embedding via SetAsChild. See behavior comment at top of file.
+    if (identifier.empty()) {
+        CefRequestContextSettings defaultSettings;
+        defaultSettings.persist_session_cookies = false;
+        CefRefPtr<CefRequestContext> ctx = CefRequestContext::CreateContext(defaultSettings, nullptr);
+        if (!ctx) {
+            fprintf(stderr, "[partition_context] WARNING: CreateContext returned null for default partition "
+                            "— falling back to global context\n");
+            ctx = CefRequestContext::GetGlobalContext();
+        }
+        registerScheme(ctx);
+        return ctx;
+    }
+
+    // Reuse cached context for persist:* partitions only.
+    if (isPersistent) {
+        std::lock_guard<std::mutex> lock(partitionContextMutex_());
+        auto& map = partitionContextMap_();
+        auto it = map.find(identifier);
+        if (it != map.end()) {
+            return it->second;
+        }
+    }
+
+    CefRequestContextSettings settings;
+    if (isPersistent) {
+        std::string partitionName = identifier.substr(8);
+        std::string cachePathStr = buildAndEnsurePartitionCachePath(partitionName);
+        if (!cachePathStr.empty()) {
+            settings.persist_session_cookies = true;
+            CefString(&settings.cache_path).FromString(cachePathStr);
+        } else {
+            fprintf(stderr, "[partition_context] webview %u: failed to build cache path for '%s', "
+                            "falling back to ephemeral\n",
+                    webviewId, identifier.c_str());
+            settings.persist_session_cookies = false;
+        }
+    } else {
+        settings.persist_session_cookies = false;
+    }
+
+    CefRefPtr<CefRequestContext> context = CefRequestContext::CreateContext(settings, nullptr);
+
+    if (!context) {
+        fprintf(stderr, "[partition_context] WARNING: CreateContext returned null for partition '%s' "
+                        "— falling back to global context (this partition will NOT be isolated)\n",
+                identifier.c_str());
+        context = CefRequestContext::GetGlobalContext();
+    }
+
+    registerScheme(context);
+
+    if (isPersistent) {
+        std::lock_guard<std::mutex> lock(partitionContextMutex_());
+        partitionContextMap_()[identifier] = context;
+    }
+
+    return context;
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_PARTITION_CONTEXT_H

package/src/native/shared/pending_resize_queue.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <algorithm>
+#include <mutex>
+#include <unordered_set>
+#include <vector>
+
+// Thread-safe queue that stores a set of dirty view pointers.
+// Enqueue is idempotent per drain cycle.
+class PendingResizeQueue {
+public:
+	void enqueue(void* view) {
+		if (!view) return;
+		std::lock_guard<std::mutex> lock(mutex_);
+		if (set_.insert(view).second) {
+			queue_.push_back(view);
+		}
+	}
+
+	std::vector<void*> drain() {
+		std::lock_guard<std::mutex> lock(mutex_);
+		std::vector<void*> out;
+		out.swap(queue_);
+		set_.clear();
+		return out;
+	}
+
+	void remove(void* view) {
+		if (!view) return;
+		std::lock_guard<std::mutex> lock(mutex_);
+		if (set_.erase(view)) {
+			queue_.erase(std::remove(queue_.begin(), queue_.end(), view), queue_.end());
+		}
+	}
+
+	bool empty() const {
+		std::lock_guard<std::mutex> lock(mutex_);
+		return queue_.empty();
+	}
+
+private:
+	mutable std::mutex mutex_;
+	std::unordered_set<void*> set_;
+	std::vector<void*> queue_;
+};

package/src/native/shared/permissions.h

@@ -0,0 +1,118 @@
+// permissions.h - Cross-platform permission cache management
+// Used for caching user media, geolocation, and notification permissions
+// across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_PERMISSIONS_H
+#define ELECTROBUN_PERMISSIONS_H
+
+#include <string>
+#include <map>
+#include <chrono>
+#include <mutex>
+#include <utility>
+
+namespace electrobun {
+
+enum class PermissionType {
+    USER_MEDIA,
+    GEOLOCATION,
+    NOTIFICATIONS,
+    OTHER
+};
+
+enum class PermissionStatus {
+    UNKNOWN,
+    ALLOWED,
+    DENIED
+};
+
+struct PermissionCacheEntry {
+    PermissionStatus status;
+    std::chrono::system_clock::time_point expiry;
+};
+
+// Thread-safe permission cache
+class PermissionCache {
+public:
+    static PermissionCache& getInstance() {
+        static PermissionCache instance;
+        return instance;
+    }
+
+    // Extract origin from a URL (e.g., "https://example.com/path" -> "https://example.com")
+    static std::string getOriginFromUrl(const std::string& url) {
+        // For views:// scheme, use a constant origin since these are local files
+        if (url.find("views://") == 0) {
+            return "views://";
+        }
+
+        // For other schemes, extract origin from URL
+        size_t protocolEnd = url.find("://");
+        if (protocolEnd == std::string::npos) return url;
+
+        size_t domainStart = protocolEnd + 3;
+        size_t pathStart = url.find('/', domainStart);
+
+        if (pathStart == std::string::npos) {
+            return url;
+        }
+
+        return url.substr(0, pathStart);
+    }
+
+    PermissionStatus get(const std::string& origin, PermissionType type) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto key = std::make_pair(origin, type);
+        auto it = cache_.find(key);
+
+        if (it != cache_.end()) {
+            // Check if permission hasn't expired
+            auto now = std::chrono::system_clock::now();
+            if (now < it->second.expiry) {
+                return it->second.status;
+            } else {
+                // Permission expired, remove from cache
+                cache_.erase(it);
+            }
+        }
+
+        return PermissionStatus::UNKNOWN;
+    }
+
+    void set(const std::string& origin, PermissionType type, PermissionStatus status) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto key = std::make_pair(origin, type);
+
+        // Cache permission for 24 hours
+        auto expiry = std::chrono::system_clock::now() + std::chrono::hours(24);
+
+        cache_[key] = {status, expiry};
+    }
+
+private:
+    PermissionCache() = default;
+    PermissionCache(const PermissionCache&) = delete;
+    PermissionCache& operator=(const PermissionCache&) = delete;
+
+    std::map<std::pair<std::string, PermissionType>, PermissionCacheEntry> cache_;
+    std::mutex mutex_;
+};
+
+// Convenience functions that use the singleton (for easier migration from existing code)
+inline std::string getOriginFromUrl(const std::string& url) {
+    return PermissionCache::getOriginFromUrl(url);
+}
+
+inline PermissionStatus getPermissionFromCache(const std::string& origin, PermissionType type) {
+    return PermissionCache::getInstance().get(origin, type);
+}
+
+inline void cachePermission(const std::string& origin, PermissionType type, PermissionStatus status) {
+    PermissionCache::getInstance().set(origin, type, status);
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_PERMISSIONS_H

package/src/native/shared/permissions_cef.h

@@ -0,0 +1,74 @@
+// permissions_cef.h - CEF-aware permission helpers
+// Must be included AFTER include/cef_app.h (or any header that pulls in
+// internal/cef_types.h) so the CEF_PERMISSION_TYPE_* constants are available.
+
+#ifndef ELECTROBUN_PERMISSIONS_CEF_H
+#define ELECTROBUN_PERMISSIONS_CEF_H
+
+// Consumers must already have included CEF headers that define
+// CEF_PERMISSION_TYPE_* (e.g. include/cef_app.h, which pulls in
+// include/internal/cef_types.h transitively).
+
+#include <string>
+#include <cstdint>
+#include <cstdio>
+
+namespace electrobun {
+
+// Decode a CEF permission bitmask (as passed to OnShowPermissionPrompt) into a
+// human-readable comma-separated list of permission names. Used to build
+// informative dialogs for permission types we don't have a dedicated UI for.
+inline std::string describeCefPermissions(uint32_t mask) {
+    std::string out;
+    auto add = [&](const char* name) {
+        if (!out.empty()) out += ", ";
+        out += name;
+    };
+
+    if (mask & CEF_PERMISSION_TYPE_AR_SESSION) add("AR session");
+    if (mask & CEF_PERMISSION_TYPE_CAMERA_PAN_TILT_ZOOM) add("Camera pan/tilt/zoom");
+    if (mask & CEF_PERMISSION_TYPE_CAMERA_STREAM) add("Camera");
+    if (mask & CEF_PERMISSION_TYPE_CAPTURED_SURFACE_CONTROL) add("Captured surface control");
+    if (mask & CEF_PERMISSION_TYPE_CLIPBOARD) add("Clipboard");
+    if (mask & CEF_PERMISSION_TYPE_TOP_LEVEL_STORAGE_ACCESS) add("Top-level storage access");
+    if (mask & CEF_PERMISSION_TYPE_DISK_QUOTA) add("Disk quota");
+    if (mask & CEF_PERMISSION_TYPE_LOCAL_FONTS) add("Local fonts");
+    if (mask & CEF_PERMISSION_TYPE_GEOLOCATION) add("Location");
+    if (mask & CEF_PERMISSION_TYPE_HAND_TRACKING) add("Hand tracking");
+    if (mask & CEF_PERMISSION_TYPE_IDENTITY_PROVIDER) add("Identity provider");
+    if (mask & CEF_PERMISSION_TYPE_IDLE_DETECTION) add("Idle detection");
+    if (mask & CEF_PERMISSION_TYPE_MIC_STREAM) add("Microphone");
+    if (mask & CEF_PERMISSION_TYPE_MIDI_SYSEX) add("MIDI system-exclusive");
+    if (mask & CEF_PERMISSION_TYPE_MULTIPLE_DOWNLOADS) add("Multiple downloads");
+    if (mask & CEF_PERMISSION_TYPE_NOTIFICATIONS) add("Notifications");
+    if (mask & CEF_PERMISSION_TYPE_KEYBOARD_LOCK) add("Keyboard lock");
+    if (mask & CEF_PERMISSION_TYPE_POINTER_LOCK) add("Pointer lock");
+    if (mask & CEF_PERMISSION_TYPE_PROTECTED_MEDIA_IDENTIFIER) add("Protected media identifier");
+    if (mask & CEF_PERMISSION_TYPE_REGISTER_PROTOCOL_HANDLER) add("Register protocol handler");
+    if (mask & CEF_PERMISSION_TYPE_STORAGE_ACCESS) add("Storage access");
+    if (mask & CEF_PERMISSION_TYPE_VR_SESSION) add("VR session");
+    if (mask & CEF_PERMISSION_TYPE_WEB_APP_INSTALLATION) add("Web app installation");
+    if (mask & CEF_PERMISSION_TYPE_WINDOW_MANAGEMENT) add("Window management");
+    if (mask & CEF_PERMISSION_TYPE_FILE_SYSTEM_ACCESS) add("File system access");
+#if CEF_API_ADDED(13600)
+    if (mask & CEF_PERMISSION_TYPE_LOCAL_NETWORK_ACCESS) add("Local network access");
+#endif
+#if CEF_API_ADDED(14500)
+    if (mask & CEF_PERMISSION_TYPE_LOCAL_NETWORK) add("Local network");
+    if (mask & CEF_PERMISSION_TYPE_LOOPBACK_NETWORK) add("Loopback network");
+#endif
+#if CEF_API_ADDED(14700)
+    if (mask & CEF_PERMISSION_TYPE_SENSORS) add("Sensors");
+#endif
+
+    if (out.empty()) {
+        char buf[64];
+        snprintf(buf, sizeof(buf), "unknown (bitmask 0x%x)", mask);
+        out = buf;
+    }
+    return out;
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_PERMISSIONS_CEF_H

package/src/native/shared/preload_script.h

@@ -0,0 +1,71 @@
+// preload_script.h - Cross-platform preload script management
+// Used for storing and managing preload scripts across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_PRELOAD_SCRIPT_H
+#define ELECTROBUN_PRELOAD_SCRIPT_H
+
+#include <string>
+#include <map>
+#include <mutex>
+
+namespace electrobun {
+
+// Represents a preload script to be injected into webviews
+struct PreloadScript {
+    std::string code;
+    bool mainFrameOnly = true;
+
+    PreloadScript() = default;
+
+    PreloadScript(const std::string& scriptCode, bool mainOnly = true)
+        : code(scriptCode), mainFrameOnly(mainOnly) {}
+
+    bool empty() const { return code.empty(); }
+};
+
+// Thread-safe storage for preload scripts by browser/webview ID
+class PreloadScriptStorage {
+public:
+    static PreloadScriptStorage& getInstance() {
+        static PreloadScriptStorage instance;
+        return instance;
+    }
+
+    void set(int browserId, const std::string& script) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        scripts_[browserId] = script;
+    }
+
+    std::string get(int browserId) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = scripts_.find(browserId);
+        if (it != scripts_.end()) {
+            return it->second;
+        }
+        return "";
+    }
+
+    void remove(int browserId) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        scripts_.erase(browserId);
+    }
+
+    void clear() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        scripts_.clear();
+    }
+
+private:
+    PreloadScriptStorage() = default;
+    PreloadScriptStorage(const PreloadScriptStorage&) = delete;
+    PreloadScriptStorage& operator=(const PreloadScriptStorage&) = delete;
+
+    mutable std::mutex mutex_;
+    std::map<int, std::string> scripts_;
+};
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_PRELOAD_SCRIPT_H

package/src/native/shared/shutdown_guard.h

@@ -0,0 +1,134 @@
+// shutdown_guard.h - Cross-platform shutdown state management
+// Prevents race conditions during application cleanup
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_SHUTDOWN_GUARD_H
+#define ELECTROBUN_SHUTDOWN_GUARD_H
+
+#include <atomic>
+#include <mutex>
+#include <thread>
+#include <chrono>
+
+namespace electrobun {
+
+// Singleton for managing global shutdown state
+// Allows code to check if shutdown is in progress and avoid race conditions
+class ShutdownManager {
+public:
+    static ShutdownManager& getInstance() {
+        static ShutdownManager instance;
+        return instance;
+    }
+
+    // Signal that shutdown has begun
+    void initiateShutdown() {
+        shuttingDown_.store(true);
+    }
+
+    // Check if shutdown is in progress
+    bool isShuttingDown() const {
+        return shuttingDown_.load();
+    }
+
+    // Reset shutdown state (use with caution, mainly for testing)
+    void reset() {
+        shuttingDown_.store(false);
+        activeOperations_.store(0);
+    }
+
+    // Increment active operations counter
+    void beginOperation() {
+        activeOperations_.fetch_add(1);
+    }
+
+    // Decrement active operations counter
+    void endOperation() {
+        activeOperations_.fetch_sub(1);
+    }
+
+    // Get count of active operations
+    int getActiveOperations() const {
+        return activeOperations_.load();
+    }
+
+    // Wait for all operations to complete (with timeout)
+    // Returns true if all operations completed, false if timeout
+    bool waitForOperationsToComplete(int maxWaitMs = 5000) {
+        int waited = 0;
+        const int sleepMs = 10;
+        while (activeOperations_.load() > 0 && waited < maxWaitMs) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleepMs));
+            waited += sleepMs;
+        }
+        return activeOperations_.load() == 0;
+    }
+
+private:
+    ShutdownManager() : shuttingDown_(false), activeOperations_(0) {}
+    ShutdownManager(const ShutdownManager&) = delete;
+    ShutdownManager& operator=(const ShutdownManager&) = delete;
+
+    std::atomic<bool> shuttingDown_;
+    std::atomic<int> activeOperations_;
+};
+
+// RAII guard for operations that shouldn't run during shutdown
+// Automatically checks shutdown state and tracks operation lifetime
+class OperationGuard {
+public:
+    OperationGuard() : valid_(!ShutdownManager::getInstance().isShuttingDown()) {
+        if (valid_) {
+            ShutdownManager::getInstance().beginOperation();
+        }
+    }
+
+    ~OperationGuard() {
+        if (valid_) {
+            ShutdownManager::getInstance().endOperation();
+        }
+    }
+
+    // Check if the operation is valid (not during shutdown)
+    bool isValid() const { return valid_; }
+
+    // Implicit conversion to bool for easy use in if statements
+    explicit operator bool() const { return valid_; }
+
+    // Non-copyable, non-movable
+    OperationGuard(const OperationGuard&) = delete;
+    OperationGuard& operator=(const OperationGuard&) = delete;
+    OperationGuard(OperationGuard&&) = delete;
+    OperationGuard& operator=(OperationGuard&&) = delete;
+
+private:
+    bool valid_;
+};
+
+// Lightweight guard that only checks shutdown state without tracking
+// Use when you don't need operation tracking, just shutdown checking
+class ShutdownCheckGuard {
+public:
+    ShutdownCheckGuard() : valid_(!ShutdownManager::getInstance().isShuttingDown()) {}
+
+    bool isValid() const { return valid_; }
+    explicit operator bool() const { return valid_; }
+
+private:
+    bool valid_;
+};
+
+// Convenience functions
+inline bool isShuttingDown() {
+    return ShutdownManager::getInstance().isShuttingDown();
+}
+
+inline void initiateShutdown() {
+    ShutdownManager::getInstance().initiateShutdown();
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_SHUTDOWN_GUARD_H