feat(linux): craete webview on new_window_req

follow-up for #1596

ref tauri-apps/tauri#13876

Author: lucasfernog

.changes/linux-new-window-req-handler.md

@@ -0,0 +1,5 @@
+---
+"wry": patch
+---
+
+Fixes `new_window_req_handler` not creating the webview on Linux when executing `window.open()`.

src/lib.rs

@@ -1709,6 +1709,7 @@ impl WebViewBuilderExtAndroid for WebViewBuilder<'_> {
 #[derive(Default)]
 pub(crate) struct PlatformSpecificWebViewAttributes {
   extension_path: Option<PathBuf>,
+  related_view: Option<webkit2gtk::WebView>,
 }
 
 #[cfg(any(
@@ -1735,6 +1736,9 @@ pub trait WebViewBuilderExtUnix<'a> {
 
   /// Set the path from which to load extensions from.
   fn with_extensions_path(self, path: impl Into<PathBuf>) -> Self;
+
+  /// Creates a new webview sharing the same web process with the provided webview.
+  fn with_related_view(self, webview: webkit2gtk::WebView) -> Self;
 }
 
 #[cfg(any(
@@ -1759,6 +1763,11 @@ impl<'a> WebViewBuilderExtUnix<'a> for WebViewBuilder<'a> {
     self.platform_specific.extension_path = Some(path.into());
     self
   }
+
+  fn with_related_view(mut self, webview: webkit2gtk::WebView) -> Self {
+    self.platform_specific.related_view.replace(webview);
+    self
+  }
 }
 
 /// The fundamental type to present a [`WebView`].

src/webkitgtk/mod.rs

@@ -27,7 +27,11 @@ use raw_window_handle::RawWindowHandle;
 use std::ffi::c_ulong;
 #[cfg(any(debug_assertions, feature = "devtools"))]
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
+use std::{
+  collections::HashMap,
+  rc::Rc,
+  sync::{Arc, Mutex},
+};
 #[cfg(any(debug_assertions, feature = "devtools"))]
 use webkit2gtk::WebInspectorExt;
 use webkit2gtk::{
@@ -275,11 +279,11 @@ impl InnerWebView {
     }
 
     // Extension loading
-    if let Some(extension_path) = pl_attrs.extension_path {
-      web_context.os.set_web_extensions_directory(&extension_path);
+    if let Some(extension_path) = &pl_attrs.extension_path {
+      web_context.os.set_web_extensions_directory(extension_path);
     }
 
-    let webview = Self::create_webview(web_context, &attributes);
+    let webview = Self::create_webview(web_context, &attributes, &pl_attrs);
 
     // Transparent
     if attributes.transparent {
@@ -379,10 +383,13 @@ impl InnerWebView {
     Ok(w)
   }
 
-  fn create_webview(web_context: &WebContext, attributes: &WebViewAttributes) -> WebView {
+  fn create_webview(
+    web_context: &WebContext,
+    attributes: &WebViewAttributes,
+    pl_attrs: &super::PlatformSpecificWebViewAttributes,
+  ) -> WebView {
     let mut builder = WebView::builder()
       .user_content_manager(&UserContentManager::new())
-      .web_context(web_context.context())
       .is_controlled_by_automation(web_context.allows_automation());
 
     if attributes.autoplay {
@@ -393,6 +400,12 @@ impl InnerWebView {
       );
     }
 
+    if let Some(related_view) = &pl_attrs.related_view {
+      builder = builder.related_view(related_view);
+    } else {
+      builder = builder.web_context(web_context.context());
+    }
+
     builder.build()
   }
 
@@ -468,35 +481,79 @@ impl InnerWebView {
       });
     }
 
-    // Navigation handler && New window handler
-    if attributes.navigation_handler.is_some() || attributes.new_window_req_handler.is_some() {
-      let new_window_req_handler = attributes.new_window_req_handler.take();
-      let navigation_handler = attributes.navigation_handler.take();
+    // window creation handler
+    if let Some(new_window_req_handler) = attributes.new_window_req_handler.take() {
+      let related_webviews = Rc::new(Mutex::new(HashMap::new()));
+      webview.connect_create(move |webview, action| {
+        let url = action
+          .request()
+          .and_then(|request| request.uri())
+          .map(|uri| uri.as_str().to_string())?;
+        if new_window_req_handler(url.clone()) {
+          let related_webviews = related_webviews.clone();
+          let toplevel = webview.toplevel().unwrap();
+          let window = toplevel.downcast::<gtk::ApplicationWindow>().unwrap();
+          let id = window.id();
+          let app = window.application().unwrap();
+
+          let window = gtk::ApplicationWindow::builder()
+            .application(&app)
+            .title(&url)
+            .build();
+          let box_ = gtk::Box::new(gtk::Orientation::Vertical, 0);
+          window.add(&box_);
+
+          let related_webviews_ = related_webviews.clone();
+          window.connect_destroy(move |_| {
+            related_webviews_.lock().unwrap().remove(&id);
+          });
 
+          window.show_all();
+          Self::new_gtk(
+            &box_,
+            WebViewAttributes {
+              ..Default::default()
+            },
+            super::PlatformSpecificWebViewAttributes {
+              related_view: Some(webview.clone()),
+              ..Default::default()
+            },
+          )
+          .map(|webview| {
+            let widget = webview.webview.upcast_ref::<gtk::Widget>().clone();
+            related_webviews.lock().unwrap().insert(id, webview);
+            widget
+          })
+          .ok()
+        } else {
+          None
+        }
+      });
+    }
+
+    // Navigation handler
+    if let Some(navigation_handler) = attributes.navigation_handler.take() {
       webview.connect_decide_policy(move |_webview, policy_decision, policy_type| {
         let handler = match policy_type {
           PolicyDecisionType::NavigationAction => &navigation_handler,
-          PolicyDecisionType::NewWindowAction => &new_window_req_handler,
           _ => return false,
         };
 
-        if let Some(handler) = handler {
-          if let Some(policy) = policy_decision.dynamic_cast_ref::<NavigationPolicyDecision>() {
-            if let Some(nav_action) = policy.navigation_action() {
-              if let Some(uri_req) = nav_action.request() {
-                if let Some(uri) = uri_req.uri() {
-                  let allow = handler(uri.to_string());
-                  let pointer = policy_decision.as_ptr();
-                  unsafe {
-                    if allow {
-                      webkit_policy_decision_use(pointer)
-                    } else {
-                      webkit_policy_decision_ignore(pointer)
-                    }
+        if let Some(policy) = policy_decision.dynamic_cast_ref::<NavigationPolicyDecision>() {
+          if let Some(nav_action) = policy.navigation_action() {
+            if let Some(uri_req) = nav_action.request() {
+              if let Some(uri) = uri_req.uri() {
+                let allow = handler(uri.to_string());
+                let pointer = policy_decision.as_ptr();
+                unsafe {
+                  if allow {
+                    webkit_policy_decision_use(pointer)
+                  } else {
+                    webkit_policy_decision_ignore(pointer)
                   }
-
-                  return true;
                 }
+
+                return true;
               }
             }
           }
@@ -936,21 +993,21 @@ impl InnerWebView {
 
   pub fn cookies_for_url(&self, url: &str) -> Result<Vec<cookie::Cookie<'static>>> {
     let (tx, rx) = std::sync::mpsc::channel();
-    self
+    if let Some(cookies_manager) = self
       .webview
       .website_data_manager()
       .and_then(|manager| manager.cookie_manager())
-      .map(|cookies_manager| {
-        cookies_manager.cookies(url, None::<&Cancellable>, move |cookies| {
-          let cookies = cookies.map(|cookies| {
-            cookies
-              .into_iter()
-              .map(Self::cookie_from_soup_cookie)
-              .collect()
-          });
-          let _ = tx.send(cookies);
-        })
-      });
+    {
+      cookies_manager.cookies(url, None::<&Cancellable>, move |cookies| {
+        let cookies = cookies.map(|cookies| {
+          cookies
+            .into_iter()
+            .map(Self::cookie_from_soup_cookie)
+            .collect()
+        });
+        let _ = tx.send(cookies);
+      })
+    }
 
     loop {
       gtk::main_iteration();
@@ -963,21 +1020,21 @@ impl InnerWebView {
 
   pub fn cookies(&self) -> Result<Vec<cookie::Cookie<'static>>> {
     let (tx, rx) = std::sync::mpsc::channel();
-    self
+    if let Some(cookies_manager) = self
       .webview
       .website_data_manager()
       .and_then(|manager| manager.cookie_manager())
-      .map(|cookies_manager| {
-        cookies_manager.all_cookies(None::<&Cancellable>, move |cookies| {
-          let cookies = cookies.map(|cookies| {
-            cookies
-              .into_iter()
-              .map(Self::cookie_from_soup_cookie)
-              .collect()
-          });
-          let _ = tx.send(cookies);
-        })
-      });
+    {
+      cookies_manager.all_cookies(None::<&Cancellable>, move |cookies| {
+        let cookies = cookies.map(|cookies| {
+          cookies
+            .into_iter()
+            .map(Self::cookie_from_soup_cookie)
+            .collect()
+        });
+        let _ = tx.send(cookies);
+      })
+    }
 
     loop {
       gtk::main_iteration();
@@ -990,16 +1047,16 @@ impl InnerWebView {
 
   pub fn set_cookie(&self, cookie: &cookie::Cookie<'_>) -> Result<()> {
     let (tx, rx) = std::sync::mpsc::channel();
-    self
+    if let Some(cookies_manager) = self
       .webview
       .website_data_manager()
       .and_then(|manager| manager.cookie_manager())
-      .map(|cookies_manager| {
-        let mut soup_cookie = Self::cookie_into_soup_cookie(cookie);
-        cookies_manager.add_cookie(&mut soup_cookie, None::<&Cancellable>, move |ret| {
-          let _ = tx.send(ret);
-        });
+    {
+      let mut soup_cookie = Self::cookie_into_soup_cookie(cookie);
+      cookies_manager.add_cookie(&mut soup_cookie, None::<&Cancellable>, move |ret| {
+        let _ = tx.send(ret);
       });
+    }
 
     loop {
       gtk::main_iteration();
@@ -1012,16 +1069,16 @@ impl InnerWebView {
 
   pub fn delete_cookie(&self, cookie: &cookie::Cookie<'_>) -> Result<()> {
     let (tx, rx) = std::sync::mpsc::channel();
-    self
+    if let Some(cookies_manager) = self
       .webview
       .website_data_manager()
       .and_then(|manager| manager.cookie_manager())
-      .map(|cookies_manager| {
-        let mut soup_cookie = Self::cookie_into_soup_cookie(cookie);
-        cookies_manager.delete_cookie(&mut soup_cookie, None::<&Cancellable>, move |ret| {
-          let _ = tx.send(ret);
-        });
+    {
+      let mut soup_cookie = Self::cookie_into_soup_cookie(cookie);
+      cookies_manager.delete_cookie(&mut soup_cookie, None::<&Cancellable>, move |ret| {
+        let _ = tx.send(ret);
       });
+    }
 
     loop {
       gtk::main_iteration();

src/webkitgtk/web_context.rs

@@ -144,7 +144,7 @@ impl WebContextExt for super::WebContext {
   where
     F: Fn(crate::WebViewId, Request<Vec<u8>>, RequestAsyncResponder) + 'static,
   {
-    self.register_custom_protocol(name.to_owned());
+    self.register_custom_protocol(name.to_owned())?;
 
     // Enable secure context
     self
@@ -326,7 +326,7 @@ impl WebContextExt for super::WebContext {
             let mut download_location =
               dirs::download_dir().unwrap_or_else(|| current_dir().unwrap_or_default());
 
-            let (mut suggested_filename, mut ext) = suggested_filename
+            let (mut suggested_filename, ext) = suggested_filename
               .split_once('.')
               .map(|(base, ext)| (base, format!(".{ext}")))
               .unwrap_or((suggested_filename, "".to_string()));