fix IPC on windows

Author: lucasfernog

crates/tauri/scripts/core.js

@@ -9,11 +9,12 @@
 
   const osName = __TEMPLATE_os_name__
   const protocolScheme = __TEMPLATE_protocol_scheme__
+  const cef = __TEMPLATE_cef__
 
   Object.defineProperty(window.__TAURI_INTERNALS__, 'convertFileSrc', {
     value: function (filePath, protocol = 'asset') {
       const path = encodeURIComponent(filePath)
-      return osName === 'windows' || osName === 'android'
+      return (osName === 'windows' || osName === 'android') && !cef
         ? `${protocolScheme}://${protocol}.localhost/${path}`
         : `${protocol}://localhost/${path}`
     }

crates/tauri/src/manager/mod.rs

@@ -19,16 +19,10 @@ use tauri_utils::{
 };
 
 use crate::{
-  app::{
+  Assets, Context, DebugAppIcon, EventName, Pattern, Runtime, StateManager, Webview, Window, app::{
     AppHandle, ChannelInterceptor, GlobalWebviewEventListener, GlobalWindowEventListener,
     OnPageLoad,
-  },
-  event::{EmitArgs, Event, EventId, EventTarget, Listeners},
-  ipc::{Invoke, InvokeHandler, RuntimeAuthority},
-  plugin::PluginStore,
-  resources::ResourceTable,
-  utils::{config::Config, PackageInfo},
-  Assets, Context, DebugAppIcon, EventName, Pattern, Runtime, StateManager, Webview, Window,
+  }, event::{EmitArgs, Event, EventId, EventTarget, Listeners}, ipc::{Invoke, InvokeHandler, RuntimeAuthority}, plugin::PluginStore, resources::ResourceTable, utils::{PackageInfo, config::Config}, webview::custom_scheme_url
 };
 
 #[cfg(desktop)]
@@ -351,22 +345,13 @@ impl<R: Runtime> AppManager<R> {
     self.config.build.dev_url.as_ref()
   }
 
-  pub(crate) fn protocol_url(&self, https: bool) -> Cow<'_, Url> {
-    if cfg!(windows) || cfg!(target_os = "android") {
-      let scheme = if https { "https" } else { "http" };
-      Cow::Owned(Url::parse(&format!("{scheme}://tauri.localhost")).unwrap())
-    } else {
-      Cow::Owned(Url::parse("tauri://localhost").unwrap())
-    }
-  }
-
   /// Get the base URL to use for webview requests.
   ///
   /// In dev mode, this will be based on the `devUrl` configuration value.
   pub(crate) fn get_url(&self, https: bool) -> Cow<'_, Url> {
     match self.base_path() {
       Some(url) => Cow::Borrowed(url),
-      _ => self.protocol_url(https),
+      _ => Cow::Owned(Url::parse(&custom_scheme_url("tauri", https)).unwrap()),
     }
   }
 
@@ -447,7 +432,7 @@ impl<R: Runtime> AppManager<R> {
               let default_src = csp_map
                 .entry("default-src".into())
                 .or_insert_with(Default::default);
-              default_src.push(crate::pattern::format_real_schema(
+              default_src.push(crate::webview::custom_scheme_url(
                 schema,
                 _use_https_schema,
               ));

crates/tauri/src/manager/webview.rs

@@ -141,7 +141,7 @@ impl<R: Runtime> WebviewManager<R> {
       isolation_origin: &match &*app_manager.pattern {
         #[cfg(feature = "isolation")]
         crate::Pattern::Isolation { schema, .. } => {
-          crate::pattern::format_real_schema(schema, use_https_scheme)
+          crate::webview::custom_scheme_url(schema, use_https_scheme)
         }
         _ => "".to_owned(),
       },
@@ -199,7 +199,7 @@ impl<R: Runtime> WebviewManager<R> {
     if let crate::Pattern::Isolation { schema, .. } = &*app_manager.pattern {
       all_initialization_scripts.push(main_frame_script(
         IsolationJavascript {
-          isolation_src: &crate::pattern::format_real_schema(schema, use_https_scheme),
+          isolation_src: crate::webview::custom_scheme_url(schema, use_https_scheme).as_str(),
           style: tauri_utils::pattern::isolation::IFRAME_STYLE,
         }
         .render_default(&Default::default())?
@@ -238,7 +238,7 @@ impl<R: Runtime> WebviewManager<R> {
     let window_url = Url::parse(&pending.url).unwrap();
     let window_origin = if window_url.scheme() == "data" {
       "null".into()
-    } else if (cfg!(windows) || cfg!(target_os = "android"))
+    } else if (!cfg!(feature = "cef") && cfg!(windows) || cfg!(target_os = "android"))
       && window_url.scheme() != "http"
       && window_url.scheme() != "https"
     {
@@ -368,7 +368,7 @@ impl<R: Runtime> WebviewManager<R> {
     struct CoreJavascript<'a> {
       os_name: &'a str,
       protocol_scheme: &'a str,
-      invoke_key: &'a str,
+      cef: bool,
     }
 
     let freeze_prototype = if app_manager.config.app.security.freeze_prototype {
@@ -383,7 +383,7 @@ impl<R: Runtime> WebviewManager<R> {
       core_script: &CoreJavascript {
         os_name: std::env::consts::OS,
         protocol_scheme: if use_https_scheme { "https" } else { "http" },
-        invoke_key: self.invoke_key(),
+        cef: cfg!(feature = "cef"),
       }
       .render_default(&Default::default())?
       .into_string(),
@@ -548,12 +548,20 @@ impl<R: Runtime> WebviewManager<R> {
     let navigation_handler = pending.navigation_handler.take();
     let app_manager = manager.manager_owned();
     let label = pending.label.clone();
+
+    #[cfg(feature = "isolation")]
+    let isolation_frame_url = if let crate::Pattern::Isolation { schema, .. } = &*pattern {
+      Some(Url::parse(&crate::webview::custom_scheme_url(schema, pending.webview_attributes.use_https_scheme)).unwrap())
+    } else {
+      None
+    };
+
     pending.navigation_handler = Some(Box::new(move |url| {
       // always allow navigation events for the isolation iframe and do not emit them for consumers
       #[cfg(feature = "isolation")]
-      if let crate::Pattern::Isolation { schema, .. } = &*pattern {
-        if url.scheme() == schema
-          && url.domain() == Some(crate::pattern::ISOLATION_IFRAME_SRC_DOMAIN)
+      if let Some(isolation_frame_url) = &isolation_frame_url {
+        if url.scheme() == isolation_frame_url.scheme()
+          && url.domain() == isolation_frame_url.domain()
         {
           return true;
         }

crates/tauri/src/pattern.rs

@@ -8,10 +8,6 @@ use std::sync::Arc;
 use serde::Serialize;
 use serialize_to_javascript::{default_template, Template};
 
-/// The domain of the isolation iframe source.
-#[cfg(feature = "isolation")]
-pub const ISOLATION_IFRAME_SRC_DOMAIN: &str = "localhost";
-
 /// An application pattern.
 #[derive(Debug)]
 pub enum Pattern {
@@ -80,13 +76,3 @@ pub(crate) enum IsolationSide {
 pub(crate) struct PatternJavascript {
   pub(crate) pattern: PatternObject,
 }
-
-#[cfg(feature = "isolation")]
-pub(crate) fn format_real_schema(schema: &str, https: bool) -> String {
-  if cfg!(windows) || cfg!(target_os = "android") {
-    let scheme = if https { "https" } else { "http" };
-    format!("{scheme}://{schema}.{ISOLATION_IFRAME_SRC_DOMAIN}/")
-  } else {
-    format!("{schema}://{ISOLATION_IFRAME_SRC_DOMAIN}/")
-  }
-}

crates/tauri/src/protocol/isolation.rs

@@ -14,7 +14,7 @@ use std::sync::Arc;
 
 use crate::{
   manager::{set_csp, webview::PROCESS_IPC_MESSAGE_FN, AppManager},
-  webview::UriSchemeProtocolHandler,
+  webview::{UriSchemeProtocolHandler, custom_scheme_url},
   Runtime,
 };
 
@@ -26,12 +26,7 @@ pub fn get<R: Runtime>(
   window_origin: String,
   use_https_scheme: bool,
 ) -> UriSchemeProtocolHandler {
-  let frame_src = if cfg!(any(windows, target_os = "android")) {
-    let https = if use_https_scheme { "https" } else { "http" };
-    format!("{https}://{schema}.localhost")
-  } else {
-    format!("{schema}:")
-  };
+  let frame_src = custom_scheme_url(schema, use_https_scheme);
 
   let assets = assets as Arc<dyn Assets<R>>;
 

crates/tauri/src/webview/mod.rs

@@ -1682,7 +1682,7 @@ tauri::Builder::default()
 
     // if from `tauri://` custom protocol
     ({
-      let protocol_url = self.manager().protocol_url(uses_https);
+      let protocol_url = Url::parse(&custom_scheme_url("tauri", uses_https)).unwrap();
       current_url.scheme() == protocol_url.scheme()
       && current_url.domain() == protocol_url.domain()
     }) ||
@@ -1706,7 +1706,7 @@ tauri::Builder::default()
         // so we check using the first part of the domain
         #[cfg(any(windows, target_os = "android"))]
         let local = {
-          let protocol_url = self.manager().protocol_url(uses_https);
+          let protocol_url = Url::parse(&custom_scheme_url("tauri", uses_https)).unwrap();
           let maybe_protocol = current_url
             .domain()
             .and_then(|d| d .split_once('.'))
@@ -2305,6 +2305,20 @@ impl<T: ScopeObject> ResolvedScope<T> {
   }
 }
 
+#[cfg(feature = "cef")]
+pub(crate) fn custom_scheme_url(scheme: &str, _https: bool) -> String {
+  format!("{scheme}://localhost")
+}
+
+#[cfg(not(feature = "cef"))]
+pub(crate) fn custom_scheme_url(scheme: &str, https: bool) -> String {
+  if cfg!(any(windows, target_os = "android")) {
+    format!("{}://{scheme}.localhost", if https { "https" } else { "http" })
+  } else {
+    format!("{scheme}://localhost")
+  }
+}
+
 #[cfg(test)]
 mod tests {
   #[test]