sparkbun 0.1.0

package/src/native/shared/thread_safe_map.h

@@ -0,0 +1,138 @@
+// thread_safe_map.h - Cross-platform thread-safe map template
+// Generic thread-safe container for tracking windows, webviews, etc.
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_THREAD_SAFE_MAP_H
+#define ELECTROBUN_THREAD_SAFE_MAP_H
+
+#include <map>
+#include <mutex>
+#include <functional>
+#include <optional>
+#include <vector>
+
+namespace electrobun {
+
+// Thread-safe wrapper around std::map
+// Provides synchronized access to key-value storage
+template<typename KeyType, typename ValueType>
+class ThreadSafeMap {
+public:
+    ThreadSafeMap() = default;
+
+    // Insert or update a value
+    void set(const KeyType& key, const ValueType& value) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        map_[key] = value;
+    }
+
+    // Insert or update with move semantics
+    void set(const KeyType& key, ValueType&& value) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        map_[key] = std::move(value);
+    }
+
+    // Get a value (returns copy for thread safety)
+    std::optional<ValueType> get(const KeyType& key) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = map_.find(key);
+        if (it != map_.end()) {
+            return it->second;
+        }
+        return std::nullopt;
+    }
+
+    // Get a value with default fallback
+    ValueType getOrDefault(const KeyType& key, const ValueType& defaultValue) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = map_.find(key);
+        if (it != map_.end()) {
+            return it->second;
+        }
+        return defaultValue;
+    }
+
+    // Check if key exists
+    bool contains(const KeyType& key) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return map_.find(key) != map_.end();
+    }
+
+    // Remove a key
+    bool remove(const KeyType& key) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return map_.erase(key) > 0;
+    }
+
+    // Clear all entries
+    void clear() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        map_.clear();
+    }
+
+    // Get size
+    size_t size() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return map_.size();
+    }
+
+    // Check if empty
+    bool empty() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return map_.empty();
+    }
+
+    // Get all keys
+    std::vector<KeyType> keys() const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        std::vector<KeyType> result;
+        result.reserve(map_.size());
+        for (const auto& pair : map_) {
+            result.push_back(pair.first);
+        }
+        return result;
+    }
+
+    // Execute a function on each entry (read-only)
+    void forEach(const std::function<void(const KeyType&, const ValueType&)>& fn) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        for (const auto& pair : map_) {
+            fn(pair.first, pair.second);
+        }
+    }
+
+    // Execute a function on a specific entry if it exists
+    // Returns true if the entry was found and the function was executed
+    bool withEntry(const KeyType& key,
+                   const std::function<void(ValueType&)>& fn) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = map_.find(key);
+        if (it != map_.end()) {
+            fn(it->second);
+            return true;
+        }
+        return false;
+    }
+
+    // Execute a function on a specific entry (const version)
+    bool withEntry(const KeyType& key,
+                   const std::function<void(const ValueType&)>& fn) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = map_.find(key);
+        if (it != map_.end()) {
+            fn(it->second);
+            return true;
+        }
+        return false;
+    }
+
+private:
+    mutable std::mutex mutex_;
+    std::map<KeyType, ValueType> map_;
+};
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_THREAD_SAFE_MAP_H

package/src/native/shared/webview_storage.h

@@ -0,0 +1,91 @@
+// webview_storage.h - Cross-platform webview content storage
+// Thread-safe storage for webview HTML content
+// Used across Windows, macOS, and Linux
+//
+// This is a header-only implementation to avoid build complexity.
+
+#ifndef ELECTROBUN_WEBVIEW_STORAGE_H
+#define ELECTROBUN_WEBVIEW_STORAGE_H
+
+#include <string>
+#include <map>
+#include <mutex>
+#include <cstdint>
+#include <cstring>
+
+namespace electrobun {
+
+// Thread-safe storage for webview HTML content
+// Replaces the duplicated webviewHTMLContent maps across platforms
+class WebviewContentStorage {
+public:
+    static WebviewContentStorage& getInstance() {
+        static WebviewContentStorage instance;
+        return instance;
+    }
+
+    void setContent(uint32_t webviewId, const std::string& content) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        content_[webviewId] = content;
+    }
+
+    void setContent(uint32_t webviewId, const char* content) {
+        if (content) {
+            setContent(webviewId, std::string(content));
+        }
+    }
+
+    std::string getContent(uint32_t webviewId) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        auto it = content_.find(webviewId);
+        if (it != content_.end()) {
+            return it->second;
+        }
+        return "";
+    }
+
+    // Returns a strdup'd string for FFI - caller must free
+    const char* getContentForFFI(uint32_t webviewId) const {
+        std::string content = getContent(webviewId);
+        if (content.empty()) {
+            return nullptr;
+        }
+        return strdup(content.c_str());
+    }
+
+    bool hasContent(uint32_t webviewId) const {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return content_.find(webviewId) != content_.end();
+    }
+
+    void removeContent(uint32_t webviewId) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        content_.erase(webviewId);
+    }
+
+    void clear() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        content_.clear();
+    }
+
+private:
+    WebviewContentStorage() = default;
+    WebviewContentStorage(const WebviewContentStorage&) = delete;
+    WebviewContentStorage& operator=(const WebviewContentStorage&) = delete;
+
+    mutable std::mutex mutex_;
+    std::map<uint32_t, std::string> content_;
+};
+
+// Convenience functions for backward compatibility with existing code
+inline void setWebviewHTMLContentShared(uint32_t webviewId, const char* htmlContent) {
+    WebviewContentStorage::getInstance().setContent(webviewId, htmlContent);
+}
+
+inline const char* getWebviewHTMLContentShared(uint32_t webviewId) {
+    return WebviewContentStorage::getInstance().getContentForFFI(webviewId);
+}
+
+} // namespace electrobun
+
+#endif // ELECTROBUN_WEBVIEW_STORAGE_H

package/src/native/win/cef_process_helper_win.cpp

@@ -0,0 +1,143 @@
+#include "include/cef_app.h"
+#include "include/cef_v8.h"
+#include <map>
+#include <mutex>
+
+class HelperApp : public CefApp, public CefRenderProcessHandler {
+public:
+    // CefApp methods:
+    virtual void OnRegisterCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar) override {
+        registrar->AddCustomScheme("views",
+            CEF_SCHEME_OPTION_STANDARD |
+            CEF_SCHEME_OPTION_CORS_ENABLED |
+            CEF_SCHEME_OPTION_SECURE | // treat it like https
+            CEF_SCHEME_OPTION_CSP_BYPASSING | // allow things like crypto.subtle
+            CEF_SCHEME_OPTION_FETCH_ENABLED);
+    }
+
+    virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() override {
+        return this;
+    }
+
+    // CefRenderProcessHandler methods:
+
+    // Called when a browser is created - receive sandbox flag via extra_info
+    virtual void OnBrowserCreated(CefRefPtr<CefBrowser> browser,
+                                  CefRefPtr<CefDictionaryValue> extra_info) override {
+        if (extra_info && extra_info->HasKey("sandbox")) {
+            bool sandbox = extra_info->GetBool("sandbox");
+            std::lock_guard<std::mutex> lock(sandbox_map_mutex_);
+            sandbox_map_[browser->GetIdentifier()] = sandbox;
+        }
+    }
+
+    // Called when a browser is destroyed - cleanup sandbox flag
+    virtual void OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) override {
+        std::lock_guard<std::mutex> lock(sandbox_map_mutex_);
+        sandbox_map_.erase(browser->GetIdentifier());
+    }
+
+    virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
+                                CefRefPtr<CefFrame> frame,
+                                CefRefPtr<CefV8Context> context) override {
+        // Check if this browser is sandboxed
+        bool is_sandboxed = false;
+        {
+            std::lock_guard<std::mutex> lock(sandbox_map_mutex_);
+            auto it = sandbox_map_.find(browser->GetIdentifier());
+            if (it != sandbox_map_.end()) {
+                is_sandboxed = it->second;
+            }
+        }
+
+        // Get the global window object
+        CefRefPtr<CefV8Context> v8Context = frame->GetV8Context();
+        v8Context->Enter();
+
+        CefRefPtr<CefV8Value> window = context->GetGlobal();
+
+        // Create eventBridge - event-only bridge (always available for all webviews, including sandboxed)
+        CefRefPtr<CefV8Value> eventBridge = CefV8Value::CreateObject(nullptr, nullptr);
+        CefRefPtr<CefV8Value> eventPostMessage = CreatePostMessageFunction(browser, "EventBridgeMessage");
+        eventBridge->SetValue("postMessage", eventPostMessage, V8_PROPERTY_ATTRIBUTE_NONE);
+        window->SetValue("__electrobunEventBridge", eventBridge, V8_PROPERTY_ATTRIBUTE_NONE);
+
+        // Only create hostBridge/bunBridge aliases and internalBridge for non-sandboxed webviews
+        if (!is_sandboxed) {
+            // Create hostBridge - user RPC bridge
+            CefRefPtr<CefV8Value> bunBridge = CefV8Value::CreateObject(nullptr, nullptr);
+            CefRefPtr<CefV8Value> bunPostMessage = CreatePostMessageFunction(browser, "BunBridgeMessage");
+            bunBridge->SetValue("postMessage", bunPostMessage, V8_PROPERTY_ATTRIBUTE_NONE);
+            window->SetValue("__electrobunHostBridge", bunBridge, V8_PROPERTY_ATTRIBUTE_NONE);
+            window->SetValue("__electrobunBunBridge", bunBridge, V8_PROPERTY_ATTRIBUTE_NONE);
+
+            // Create internalBridge - internal RPC bridge
+            CefRefPtr<CefV8Value> internalBridge = CefV8Value::CreateObject(nullptr, nullptr);
+            CefRefPtr<CefV8Value> internalPostMessage = CreatePostMessageFunction(browser, "internalMessage");
+            internalBridge->SetValue("postMessage", internalPostMessage, V8_PROPERTY_ATTRIBUTE_NONE);
+            window->SetValue("__electrobunInternalBridge", internalBridge, V8_PROPERTY_ATTRIBUTE_NONE);
+        }
+
+        v8Context->Exit();
+    }
+
+private:
+    // Map of browser ID to sandbox flag
+    std::map<int, bool> sandbox_map_;
+    std::mutex sandbox_map_mutex_;
+    // Helper class to handle V8 function calls
+    class V8Handler : public CefV8Handler {
+    public:
+        V8Handler(CefRefPtr<CefBrowser> browser, const CefString& messageName)
+            : browser_(browser), message_name_(messageName) {}
+
+        virtual bool Execute(const CefString& name,
+                           CefRefPtr<CefV8Value> object,
+                           const CefV8ValueList& arguments,
+                           CefRefPtr<CefV8Value>& retval,
+                           CefString& exception) override {
+            if (arguments.size() > 0 && arguments[0]->IsString()) {
+                // Create and send process message to the main process
+                CefRefPtr<CefFrame> mainFrame = browser_->GetMainFrame();
+                if (mainFrame) {
+                    CefRefPtr<CefProcessMessage> message = CefProcessMessage::Create(message_name_);
+                    message->GetArgumentList()->SetString(0, arguments[0]->GetStringValue());
+                    mainFrame->SendProcessMessage(PID_BROWSER, message);
+                }
+                return true;
+            }
+            return false;
+        }
+
+    private:
+        CefRefPtr<CefBrowser> browser_;
+        CefString message_name_;
+        IMPLEMENT_REFCOUNTING(V8Handler);
+    };
+
+    CefRefPtr<CefV8Value> CreatePostMessageFunction(CefRefPtr<CefBrowser> browser,
+                                                   const CefString& messageName) {
+        return CefV8Value::CreateFunction(
+            "postMessage",
+            new V8Handler(browser, messageName)
+        );
+    }
+
+    IMPLEMENT_REFCOUNTING(HelperApp);
+};
+
+// Entry point function for Windows sub-processes.
+int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) {
+    // Provide CEF with command-line arguments.
+    CefMainArgs main_args(hInstance);
+
+    CefRefPtr<CefApp> app(new HelperApp);
+
+    // Execute the sub-process.
+    return CefExecuteProcess(main_args, app, nullptr);
+}
+
+// Alternative entry point for console applications
+int main() {
+    return wWinMain(GetModuleHandle(NULL), NULL, GetCommandLineW(), SW_HIDE);
+}