bunite-core 0.12.1 → 0.16.0

package/src/native/shared/ffi_exports.h

@@ -15,8 +15,7 @@
 extern "C" {
 #endif
 
-/** ABI version. Bump on any breaking change to symbol set / signatures.
- *  v5 (2026-05): adds `bunite_view_evaluate` + `evaluate-result` webview event. */
+/** ABI version. Bump on any breaking change to symbol set / signatures. */
 BUNITE_EXPORT int32_t bunite_abi_version(void);
 BUNITE_EXPORT void bunite_set_log_level(int32_t level);
 BUNITE_EXPORT bool bunite_init(
@@ -124,6 +123,205 @@ BUNITE_EXPORT void bunite_view_set_anchor(uint32_t view_id, int mode, double ins
 BUNITE_EXPORT void bunite_view_go_back(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_reload(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_remove(uint32_t view_id);
+
+/* Input dispatch (ABI v6). Coordinates are CSS px, viewport-relative (TS
+ * normalizes devicePixelRatio + container offset). Modifier bitmask is
+ * Alt=1, Ctrl=2, Meta=4, Shift=8. Backends translate to their native form.
+ * No result envelope — `nativeInputTrusted` capability indicates DOM trust. */
+BUNITE_EXPORT void bunite_view_click(
+	uint32_t view_id,
+	double x,
+	double y,
+	int32_t button,       /* 0=left, 1=middle, 2=right */
+	int32_t click_count,  /* >=1 */
+	uint32_t modifiers
+);
+/** Type UTF-8 text. Each codepoint becomes a CHAR / insertText event — no IME composition. */
+BUNITE_EXPORT void bunite_view_type(uint32_t view_id, const char* text);
+/** Press a key: down + (optional) char + up.
+ *  `windows_vk_code` is Win32 VK_* for CEF / WebView2 CDP path.
+ *  `mac_key_code` is the Quartz Event Services hardware key code (kVK_*) — separate
+ *  from Win VK because DOM `KeyboardEvent.code` is derived from this on WebKit.
+ *  `key` / `code` are DOM `KeyboardEvent.key` / `.code` strings, passed to CDP so
+ *  the page sees the correct values. `character` is UTF-8 for the CHAR event;
+ *  empty = skip char. 0 vk codes = skip the virtual-key down/up.
+ *  `action`: 0=down only, 1=up only, 2=both (default). For Playwright-style
+ *  modifier-held wrap (keydown → click → keyup). CHAR follows Playwright rule:
+ *  emitted with down only when character is non-empty.
+ *  `extended`: Win scancode 0xE0 prefix — Numpad-Enter AND nav-cluster
+ *  (Arrow/Home/End/Insert/Delete/PageUp/PageDown/Meta/ContextMenu). Drives CEF
+ *  `native_key_code`. Other backends ignore.
+ *  `location`: DOM `KeyboardEvent.location` (0=standard, 1=left mod, 2=right
+ *  mod, 3=numpad). WV2 CDP forwards as `location`. Most extended keys are
+ *  location 0 — only NumpadEnter is location 3 here. */
+BUNITE_EXPORT void bunite_view_press(
+	uint32_t view_id,
+	int32_t windows_vk_code,
+	int32_t mac_key_code,
+	const char* key,
+	const char* code,
+	const char* character,
+	uint32_t modifiers,
+	int32_t action,
+	bool extended,
+	int32_t location
+);
+/** Scroll at (x, y). dx/dy in CSS px; positive = right/down. */
+BUNITE_EXPORT void bunite_view_scroll(
+	uint32_t view_id,
+	double dx,
+	double dy,
+	double x,
+	double y,
+	uint32_t modifiers
+);
+
+/** Raw mouse primitive. `action` 0=move, 1=down, 2=up. `button` 0=left, 1=middle,
+ *  2=right (ignored for move). Coordinates are CSS px viewport-relative. Drag is
+ *  composed = down → move(s) → up. Backends without input support (linux GTK)
+ *  treat as no-op. `modifiers` per-call atomic — no sticky state. */
+BUNITE_EXPORT void bunite_view_mouse(
+	uint32_t view_id,
+	int32_t action,
+	double x,
+	double y,
+	int32_t button,
+	uint32_t modifiers
+);
+
+/** Respond to a page-initiated modal dialog previously announced via the
+ *  webview event channel as `dialog` (`{requestId, kind, message, defaultPrompt?}`).
+ *  `accept` decides confirm/beforeunload outcome and gates whether `text` is
+ *  applied to `prompt`. Backends release the held page execution. */
+BUNITE_EXPORT void bunite_view_respond_dialog(
+	uint32_t view_id,
+	uint32_t request_id,
+	bool accept,
+	const char* text
+);
+
+/** Per-view automation capability bitset. Two categories: method gate
+ *  (bit=false → method must not be called) and property advertise (bit=false
+ *  → method runs, property degrades). See `.agents/architecture.md`. */
+enum BuniteCapBit {
+	/* method gate */
+	BUNITE_CAP_EVALUATE             = 1u << 0,
+	BUNITE_CAP_SURFACE_EVENTS       = 1u << 2,
+	BUNITE_CAP_CLICK                = 1u << 4,
+	BUNITE_CAP_TYPE                 = 1u << 5,
+	BUNITE_CAP_PRESS                = 1u << 6,
+	BUNITE_CAP_SCROLL               = 1u << 7,
+	BUNITE_CAP_SCREENSHOT           = 1u << 8,
+	BUNITE_CAP_MOUSE                = 1u << 11,
+	BUNITE_CAP_DIALOGS              = 1u << 12,
+	BUNITE_CAP_CONSOLE              = 1u << 13,
+	BUNITE_CAP_AX                   = 1u << 15,
+	BUNITE_CAP_BOUNDING_RECT        = 1u << 16,
+	BUNITE_CAP_FRAMES               = 1u << 17,
+	BUNITE_CAP_DOWNLOADS            = 1u << 18,
+	BUNITE_CAP_POPUPS               = 1u << 19,
+	BUNITE_CAP_RESOLVE_AND_CLICK    = 1u << 20,
+
+	/* property advertise */
+	BUNITE_CAP_CROSS_ORIGIN_EVAL    = 1u << 1,
+	BUNITE_CAP_NATIVE_INPUT_TRUSTED = 1u << 3,  /* click/type/press/mouse isTrusted */
+	BUNITE_CAP_FORMAT_PNG           = 1u << 9,
+	BUNITE_CAP_FORMAT_JPEG          = 1u << 10,
+};
+BUNITE_EXPORT uint32_t bunite_view_capabilities(uint32_t view_id);
+
+/** Capture the visible viewport as a PNG/JPEG image. Async — result reported
+ *  via the webview event handler as `screenshot-result` with payload
+ *    { requestId, ok: true, format, mime, dataBase64 }
+ *    { requestId, ok: false, code, message }
+ *  Error codes: `not_supported`, `runtime_error`, `timeout`, `black_frame` (CEF
+ *  compositor surface unreachable). `quality` is 0–100 for JPEG only — ignored
+ *  for PNG, and ignored entirely on WebView2 (`CapturePreview` has no quality
+ *  parameter; output uses Edge's default ~80). `dataBase64` is base64-encoded
+ *  image bytes; TS layer decodes. */
+BUNITE_EXPORT void bunite_view_screenshot(
+	uint32_t view_id,
+	uint32_t request_id,
+	const char* format,
+	int32_t quality
+);
+
+/** Snapshot the accessibility tree (CDP `Accessibility.getFullAXTree`). Async —
+ *  result reported via webview event handler as `accessibility-result` payload
+ *    { requestId, ok: true, tree: {nodes: [<CDP AXNode flat list>]} }
+ *    { requestId, ok: false, code, message }
+ *  TS builds the nested tree from `childIds`. mac/linux always emit
+ *  `not_supported` (no public ax tree API). `interesting_only` is reserved and
+ *  currently unused on the native side (filter is TS-side). */
+BUNITE_EXPORT void bunite_view_accessibility_snapshot(
+	uint32_t view_id,
+	uint32_t request_id,
+	int32_t interesting_only
+);
+
+/** Enumerate frames in the view. Async — result reported via webview event
+ *  `list-frames-result` payload
+ *    { requestId, ok: true, frames: [{frameId, parentFrameId, origin, url, name?}] }
+ *    { requestId, ok: false, code, message }
+ *  Codes: `not_supported`, `runtime_error`. mac/linux emit `not_supported`. */
+BUNITE_EXPORT void bunite_view_list_frames(uint32_t view_id, uint32_t request_id);
+
+/** Evaluate `script` in the target frame's isolated world (CDP
+ *  `Page.createIsolatedWorld` + `Runtime.evaluate`). Page main-world JS
+ *  variables are NOT visible; DOM access works. Result reused via the
+ *  existing `evaluate-result` event. `frame_id` empty/null delegates to
+ *  `bunite_view_evaluate` (main frame, main world). */
+BUNITE_EXPORT void bunite_view_evaluate_in_frame(
+	uint32_t view_id,
+	uint32_t request_id,
+	const char* script,
+	const char* frame_id
+);
+
+/** Atomic selector resolve + native click. Async via `resolve-and-click-result`:
+ *    { requestId, ok: true, rect, isTrustedEvent }
+ *    { requestId, ok: false, code, message }
+ *  Codes: not_found / not_visible / runtime_error / cross_origin / not_supported.
+ *  `frame_id` non-empty selects a same-origin iframe (rect viewport-normalized);
+ *  cross-origin → `cross_origin`, mac/linux → `not_supported`. scrollIntoView is
+ *  automatic. `isTrustedEvent` is empirical per backend; CEF/WV2 CDP path and
+ *  mac NSEvent direct dispatch all produce trusted events (all `true`). */
+BUNITE_EXPORT void bunite_view_resolve_and_click(
+	uint32_t view_id,
+	uint32_t request_id,
+	const char* selector,
+	const char* frame_id,
+	int32_t button,
+	int32_t click_count,
+	uint32_t modifiers
+);
+
+/** Set per-view download policy. `policy`: 0=auto (allow + emit lifecycle),
+ *  1=ask (not implemented for v10, treated as block), 2=block (default).
+ *  `download_dir` (utf-8) optionally overrides backend default save dir.
+ *  Lifecycle events emit as `download-event` payloads
+ *    { kind: "started"|"progress"|"completed"|"failed"|"blocked", id, ...fields }
+ *  See `DownloadEvent` (TS) for the per-kind field set. */
+BUNITE_EXPORT void bunite_view_set_download_policy(
+	uint32_t view_id,
+	int32_t policy,
+	const char* download_dir
+);
+
+/** Adopt a popup-minted view. Native must have previously emitted a
+ *  `popup-requested` event (carrying `newSurfaceId`); host calls this to attach
+ *  the pre-minted view to the target window + bounds. `host_window_id` is the
+ *  destination `WindowHost.id`. */
+BUNITE_EXPORT void bunite_view_popup_accept(
+	uint32_t new_view_id,
+	uint32_t host_window_id,
+	double x, double y, double w, double h
+);
+
+/** Discard a popup-minted view that wasn't adopted (or that host wants to
+ *  reject). Native destroys the controller/browser. Idempotent. */
+BUNITE_EXPORT void bunite_view_popup_dismiss(uint32_t new_view_id);
+
 BUNITE_EXPORT void bunite_view_open_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_close_devtools(uint32_t view_id);
 BUNITE_EXPORT void bunite_view_toggle_devtools(uint32_t view_id);

package/src/native/win/native_host_cef.cpp

@@ -85,8 +85,12 @@ class BuniteCefClient
     public CefRequestHandler,
     public CefResourceRequestHandler,
     public CefPermissionHandler,
-    public CefDisplayHandler {
+    public CefDisplayHandler,
+    public CefJSDialogHandler,
+    public CefDownloadHandler {
 public:
+  // BuniteCefClient is constructed 1:1 with a `ViewHost*`; `last_title_` is
+  // therefore per-view. OnTitleChange runs on the CEF UI thread (single).
   explicit BuniteCefClient(ViewHost* view)
     : view_(view) {}
 
@@ -95,6 +99,113 @@ public:
   CefRefPtr<CefRequestHandler> GetRequestHandler() override { return this; }
   CefRefPtr<CefPermissionHandler> GetPermissionHandler() override { return this; }
   CefRefPtr<CefDisplayHandler> GetDisplayHandler() override { return this; }
+  CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() override { return this; }
+  CefRefPtr<CefDownloadHandler> GetDownloadHandler() override { return this; }
+
+  bool OnBeforeDownload(CefRefPtr<CefBrowser>, CefRefPtr<CefDownloadItem> item,
+                        const CefString& suggested_name,
+                        CefRefPtr<CefBeforeDownloadCallback> callback) override {
+    CEF_REQUIRE_UI_THREAD();
+    int32_t policy = view_->download_policy.load();
+    std::string id = "cef-" + std::to_string(item->GetId());
+    std::string url = item->GetURL().ToString();
+    std::string mime = item->GetMimeType().ToString();
+    int64_t total = item->GetTotalBytes();
+    std::string suggested = suggested_name.ToString();
+    // Only policy=0 (auto) allows. `ask` (1) falls back to block — distinguished
+    // via blocked.reason so callers can detect the unsupported policy path.
+    if (policy != 0) {
+      const char* reason = (policy == 1) ? "ask-not-implemented" : "host-policy";
+      std::string payload = "{\"kind\":\"blocked\",\"id\":\"" + id +
+                            "\",\"url\":\"" + bunite_win::escapeJsonString(url) +
+                            "\",\"reason\":\"" + reason + "\"}";
+      bunite_win::emitWebviewEvent(view_->id, "download-event", payload);
+      return true;  // not calling callback->Continue → cancels.
+    }
+    // auto: build target path. If host set download_dir, use it; else CEF defaults to user Downloads.
+    std::string target = view_->download_dir;
+    if (!target.empty()) {
+      if (target.back() != '\\' && target.back() != '/') target.push_back('\\');
+      target += suggested;
+    }
+    callback->Continue(target, false);  // false = no Save-As dialog.
+    std::string payload = "{\"kind\":\"started\",\"id\":\"" + id +
+                          "\",\"url\":\"" + bunite_win::escapeJsonString(url) +
+                          "\",\"suggestedFilename\":\"" + bunite_win::escapeJsonString(suggested) +
+                          "\",\"mimeType\":\"" + bunite_win::escapeJsonString(mime) + "\"";
+    if (total > 0) payload += ",\"sizeBytes\":" + std::to_string(total);
+    payload += "}";
+    bunite_win::emitWebviewEvent(view_->id, "download-event", payload);
+    return true;
+  }
+
+  void OnDownloadUpdated(CefRefPtr<CefBrowser>, CefRefPtr<CefDownloadItem> item,
+                         CefRefPtr<CefDownloadItemCallback> /*callback*/) override {
+    CEF_REQUIRE_UI_THREAD();
+    std::string id = "cef-" + std::to_string(item->GetId());
+    if (item->IsComplete()) {
+      std::string path = item->GetFullPath().ToString();
+      std::string payload = "{\"kind\":\"completed\",\"id\":\"" + id +
+                            "\",\"localPath\":\"" + bunite_win::escapeJsonString(path) + "\"}";
+      bunite_win::emitWebviewEvent(view_->id, "download-event", payload);
+    } else if (item->IsCanceled()) {
+      std::string payload = "{\"kind\":\"failed\",\"id\":\"" + id +
+                            "\",\"reason\":\"canceled\"}";
+      bunite_win::emitWebviewEvent(view_->id, "download-event", payload);
+    } else if (item->IsInProgress()) {
+      int64_t rec = item->GetReceivedBytes();
+      int64_t tot = item->GetTotalBytes();
+      std::string payload = "{\"kind\":\"progress\",\"id\":\"" + id +
+                            "\",\"receivedBytes\":" + std::to_string(rec);
+      if (tot > 0) payload += ",\"totalBytes\":" + std::to_string(tot);
+      payload += "}";
+      bunite_win::emitWebviewEvent(view_->id, "download-event", payload);
+    }
+  }
+
+  bool OnJSDialog(CefRefPtr<CefBrowser>, const CefString& /*origin_url*/,
+                  JSDialogType dialog_type, const CefString& message_text,
+                  const CefString& default_prompt_text,
+                  CefRefPtr<CefJSDialogCallback> callback,
+                  bool& suppress_message) override {
+    CEF_REQUIRE_UI_THREAD();
+    const char* kind = (dialog_type == JSDIALOGTYPE_ALERT) ? "alert"
+                     : (dialog_type == JSDIALOGTYPE_CONFIRM) ? "confirm" : "prompt";
+    const uint32_t rid = view_->next_dialog_request_id++;
+    view_->pending_dialogs[rid] = callback;
+    BUNITE_INFO("cef/dialog: OnJSDialog view=%u kind=%s rid=%u", view_->id, kind, rid);
+    // CEF asserts !suppress_message when return=true (custom dialog path).
+    suppress_message = false;
+    std::string payload = "{\"requestId\":" + std::to_string(rid) +
+                          ",\"kind\":\"" + kind +
+                          "\",\"message\":\"" + bunite_win::escapeJsonString(message_text.ToString()) + "\"";
+    if (dialog_type == JSDIALOGTYPE_PROMPT) {
+      payload += ",\"defaultPrompt\":\"" + bunite_win::escapeJsonString(default_prompt_text.ToString()) + "\"";
+    }
+    payload += "}";
+    bunite_win::emitWebviewEvent(view_->id, "dialog", payload);
+    return true;  // handled — CEF will not show its own UI.
+  }
+
+  bool OnBeforeUnloadDialog(CefRefPtr<CefBrowser>, const CefString& message_text,
+                            bool /*is_reload*/,
+                            CefRefPtr<CefJSDialogCallback> callback) override {
+    CEF_REQUIRE_UI_THREAD();
+    const uint32_t rid = view_->next_dialog_request_id++;
+    view_->pending_dialogs[rid] = callback;
+    std::string payload = "{\"requestId\":" + std::to_string(rid) +
+                          ",\"kind\":\"beforeunload\",\"message\":\"" +
+                          bunite_win::escapeJsonString(message_text.ToString()) + "\"}";
+    bunite_win::emitWebviewEvent(view_->id, "dialog", payload);
+    return true;
+  }
+
+  void OnResetDialogState(CefRefPtr<CefBrowser>) override {
+    CEF_REQUIRE_UI_THREAD();
+    // Tab navigation / reload clears any stuck dialogs. Drop the callbacks —
+    // CEF won't deliver them anymore, and the page is already moving on.
+    view_->pending_dialogs.clear();
+  }
 
   bool OnProcessMessageReceived(
     CefRefPtr<CefBrowser> /*browser*/,
@@ -122,10 +233,25 @@ public:
 
   void OnTitleChange(CefRefPtr<CefBrowser>, const CefString& title) override {
     CEF_REQUIRE_UI_THREAD();
-    std::string payload = "{\"title\":\"" + bunite_win::escapeJsonString(title.ToString()) + "\"}";
+    std::string s = title.ToString();
+    // Filter the transients CEF emits during initial / mid-load (blank doc
+    // placeholder, momentary URL-as-title) and dedup on the last emitted value.
+    if (s.empty()) return;
+    if (s == last_title_) return;
+    last_title_ = s;
+    std::string payload = "{\"title\":\"" + bunite_win::escapeJsonString(s) + "\"}";
     bunite_win::emitWebviewEvent(view_->id, "title-changed", payload);
   }
 
+  void OnAddressChange(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame,
+                       const CefString& url) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    // URL commit point — parity with WV2 SourceChanged / mac didCommitNavigation.
+    // Distinct from load-finish (which is OnLoadEnd).
+    bunite_win::emitWebviewEvent(view_->id, "did-navigate", url.ToString());
+  }
+
   void OnBeforeDevToolsPopup(
     CefRefPtr<CefBrowser>,
     CefWindowInfo&,
@@ -153,6 +279,7 @@ public:
   void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
     CEF_REQUIRE_UI_THREAD();
     view_->browser = browser;
+    bunite_win::registerCdpObserverForView(view_);
     {
       std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
       g_runtime.browser_to_view_id[browser->GetIdentifier()] = view_->id;
@@ -192,6 +319,19 @@ public:
     }
 
     bunite_win::emitWebviewEvent(view_->id, "view-ready");
+
+    if (view_->is_popup_pending) {
+      if (view_->popup_dismiss_requested) {
+        view_->closing.store(true);
+        browser->GetHost()->CloseBrowser(true);
+        return;
+      }
+      if (view_->pending_popup_accept) {
+        auto p = *view_->pending_popup_accept;
+        view_->pending_popup_accept.reset();
+        bunite_win::applyPopupAccept(view_, p.host_window_id, p.x, p.y, p.w, p.h);
+      }
+    }
   }
 
   bool DoClose(CefRefPtr<CefBrowser>) override {
@@ -255,19 +395,39 @@ public:
     CefLifeSpanHandler::WindowOpenDisposition,
     bool,
     const CefPopupFeatures&,
-    CefWindowInfo&,
-    CefRefPtr<CefClient>&,
+    CefWindowInfo& window_info,
+    CefRefPtr<CefClient>& client,
     CefBrowserSettings&,
     CefRefPtr<CefDictionaryValue>&,
     bool*
   ) override {
     CEF_REQUIRE_UI_THREAD();
-    bunite_win::emitWebviewEvent(
-      view_->id,
-      "new-window-open",
-      "{\"url\":\"" + bunite_win::escapeJsonString(target_url.ToString()) + "\"}"
-    );
-    return true;
+    // Popup IDs live in the upper u32 half; TS allocator stays below.
+    static std::atomic<uint32_t> g_popup_seq{0x80000000u};
+    uint32_t new_view_id = g_popup_seq.fetch_add(1);
+    auto* popup = new ViewHost();
+    popup->id = new_view_id;
+    popup->window = nullptr;
+    popup->is_popup_pending = true;
+    {
+      std::lock_guard<std::mutex> lock(g_runtime.object_mutex);
+      g_runtime.views_by_id[new_view_id] = popup;
+    }
+    // Initial parent = runtime message window; host adopts and reparents later.
+    window_info.SetAsChild(g_runtime.message_window, CefRect{0, 0, 0, 0});
+    window_info.style = WS_CHILD;
+    client = new BuniteCefClient(popup);
+    std::string payload = "{\"newSurfaceId\":" + std::to_string(new_view_id) +
+                          ",\"url\":\"" + bunite_win::escapeJsonString(target_url.ToString()) +
+                          "\",\"disposition\":\"popup\"}";
+    bunite_win::emitWebviewEvent(view_->id, "popup-requested", payload);
+    return false;  // allow CEF to create the popup browser.
+  }
+
+  void OnLoadStart(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame, TransitionType) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    bunite_win::emitWebviewEvent(view_->id, "load-start", frame->GetURL().ToString());
   }
 
   void OnLoadEnd(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame, int) override {
@@ -277,10 +437,24 @@ public:
     }
 
     const std::string url = frame->GetURL().ToString();
-    bunite_win::emitWebviewEvent(view_->id, "did-navigate", url);
+    bunite_win::emitWebviewEvent(view_->id, "load-finish", url);
     bunite_win::emitWebviewEvent(view_->id, "dom-ready", url);
   }
 
+  void OnLoadError(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame,
+                   ErrorCode errorCode, const CefString& errorText, const CefString& failedUrl) override {
+    CEF_REQUIRE_UI_THREAD();
+    if (!frame->IsMain()) return;
+    // ERR_ABORTED fires on user-initiated navigation cancellation — not a
+    // failure from the consumer's perspective. Filter to align with WV2.
+    if (errorCode == ERR_ABORTED) return;
+    std::string reason = errorText.ToString();
+    if (reason.empty()) reason = "ERR_" + std::to_string(static_cast<int>(errorCode));
+    std::string payload = "{\"url\":\"" + bunite_win::escapeJsonString(failedUrl.ToString()) +
+                          "\",\"reason\":\"" + bunite_win::escapeJsonString(reason) + "\"}";
+    bunite_win::emitWebviewEvent(view_->id, "load-fail", payload);
+  }
+
   bool OnShowPermissionPrompt(
     CefRefPtr<CefBrowser>,
     uint64_t,
@@ -341,6 +515,7 @@ public:
 
 private:
   ViewHost* view_;
+  std::string last_title_;
 
   IMPLEMENT_REFCOUNTING(BuniteCefClient);
 };