tauri-apps · wravery · Jan 22, 2025 · Jan 21, 2025 · Jan 21, 2025 · Jan 22, 2025
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -25,11 +25,49 @@ jobs:
 
       - name: Check fmt
         run: cargo fmt --check
-      - name: Build
+
+      - name: Install ninja
         run: |
           ${{ matrix.os == 'macos-latest' && 'brew install ninja'
             || (matrix.os == 'windows-latest' && 'choco install ninja'
             || 'echo "ninja already installed"') }}
-          cargo build --verbose
+
+      - name: Cache CEF
+        id: cache-cef
+        uses: actions/cache@v4.2.0
+        with:
+          path: ~/.local/share/cef
+          key: cef-${{ matrix.os }}-${{ hashFiles('Cargo.toml') }}
+
+      - name: ${{ steps.cache-cef.outputs.cache-hit && 'Use cache' || 'Export CEF' }}
+        run: |
+          ${{ steps.cache-cef.outputs.cache-hit && 'echo "Cached CEF"'
+            || (matrix.os == 'windows-latest'
+              && 'cargo run -p export-cef-dir -- "$env:USERPROFILE/.local/share/cef"'
+              || 'cargo run -p export-cef-dir -- "$HOME/.local/share/cef"')
+          }}
+          echo "CEF_PATH=${{ matrix.os == 'windows-latest'
+            && '$env:USERPROFILE'
+            || '$HOME'
+          }}/.local/share/cef" >> $${{ matrix.os == 'windows-latest'
+            && 'env:'
+            || ''
+          }}GITHUB_ENV
+          echo "${{ matrix.os == 'macos-latest'
+            && 'DYLD_FALLBACK_LIBRARY_PATH'
+            || (matrix.os == 'windows-latest'
+              && 'PATH'
+              || 'LD_LIBRARY_PATH') }}=${{ matrix.os == 'macos-latest'
+                && '$DYLD_FALLBACK_LIBRARY_PATH:$HOME/.local/share/cef'
+                || (matrix.os == 'windows-latest'
+                  && '$env:PATH;$env:USERPROFILE/.local/share/cef'
+                  || '$LD_LIBRARY_PATH:$HOME/.local/share/cef') }}" >> $${{ matrix.os == 'windows-latest'
+                    && 'env:'
+                    || ''
+                  }}GITHUB_ENV
+
+      - name: Build
+        run: cargo build --verbose
+
       - name: Run tests
         run: cargo test --verbose
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -4,6 +4,7 @@ resolver = "2"
 members = [
     "download-cef",
     "update-bindings",
+    "export-cef-dir",
     "sys",
     "cef",
 ]

diff --git a/cef/src/library_loader.rs b/cef/src/library_loader.rs
@@ -30,7 +30,10 @@ impl LibraryLoader {
 
     fn load_library(name: &std::path::Path) -> bool {
         use std::os::unix::ffi::OsStrExt;
-        unsafe { load_library(Some(&*name.as_os_str().as_bytes().as_ptr().cast())) == 1 }
+        let Ok(name) = std::ffi::CString::new(name.as_os_str().as_bytes()) else {
+            return false;
+        };
+        unsafe { load_library(Some(&*name.as_ptr().cast())) == 1 }
     }
 }
 

diff --git a/export-cef-dir/Cargo.toml b/export-cef-dir/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "export-cef-dir"
+publish = false
+
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+cef-dll-sys.workspace = true
+clap.workspace = true
+
+[build-dependencies]
+anyhow.workspace = true
diff --git a/export-cef-dir/build.rs b/export-cef-dir/build.rs
@@ -0,0 +1,10 @@
+use std::{env, fs::File, io::Write, path::PathBuf};
+
+fn main() -> anyhow::Result<()> {
+    let cef_dir = env::var("DEP_CEF_DLL_WRAPPER_CEF_DIR")?;
+    eprintln!("DEP_CEF_DLL_WRAPPER_CEF_DIR: {cef_dir}");
+    let cef_dir_rs = PathBuf::from(env::var("OUT_DIR")?).join("cef_dir.rs");
+    let mut cef_dir_rs = File::create(cef_dir_rs)?;
+    writeln!(&mut cef_dir_rs, r#"const CEF_DIR: &str = r"{cef_dir}";"#)?;
+    Ok(())
+}
diff --git a/export-cef-dir/src/main.rs b/export-cef-dir/src/main.rs
@@ -0,0 +1,60 @@
+use clap::Parser;
+use std::{
+    fs, io,
+    path::{Path, PathBuf},
+};
+
+include!(concat!(env!("OUT_DIR"), "/cef_dir.rs"));
+
+#[derive(Parser, Debug)]
+#[command(about, long_about = None)]
+struct Args {
+    #[arg(short, long, default_value = "false")]
+    force: bool,
+    target: String,
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = Args::parse();
+    let target = PathBuf::from(args.target);
+
+    if target.exists() {
+        if !args.force {
+            return Err(anyhow::anyhow!(
+                "target directory already exists: {}",
+                target.display()
+            ));
+        }
+
+        let parent = target.parent();
+        let dir = target
+            .file_name()
+            .ok_or_else(|| anyhow::anyhow!("invalid target directory: {}", target.display()))?;
+        let old_target = parent.map(|p| p.join(dir));
+        let old_target = old_target.as_ref().unwrap_or(&target);
+        fs::rename(&target, old_target)?;
+        fs::remove_dir_all(old_target)?
+    }
+
+    copy_directory(PathBuf::from(CEF_DIR), &target)?;
+
+    Ok(())
+}
+
+fn copy_directory<P, Q>(src: P, dst: Q) -> io::Result<()>
+where
+    P: AsRef<Path>,
+    Q: AsRef<Path>,
+{
+    fs::create_dir_all(&dst)?;
+    for entry in fs::read_dir(&src)? {
+        let entry = entry?;
+        let dst_path = dst.as_ref().join(entry.file_name());
+        if entry.file_type()?.is_dir() {
+            copy_directory(&entry.path(), &dst_path)?;
+        } else {
+            fs::copy(&entry.path(), &dst_path)?;
+        }
+    }
+    Ok(())
+}
diff --git a/sys/build.rs b/sys/build.rs
@@ -18,7 +18,7 @@ fn main() -> anyhow::Result<()> {
         Ok(cef_path) => {
        
1E0A
     // Allow overriding the CEF path with environment variables.
             println!("Using CEF path from environment: {cef_path}");
-            PathBuf::from(cef_path).canonicalize()?
+            PathBuf::from(cef_path)
         }
         Err(_) => {
             let out_dir = PathBuf::from(env::var("OUT_DIR")?);

diff --git a/sys/src/lib.rs b/sys/src/lib.rs
@@ -77,11 +77,10 @@ mod test {
                     .join(FRAMEWORK_PATH)
                     .canonicalize()
                     .expect("failed to get framework path");
+                let framework_dir = std::ffi::CString::new(framework_dir.as_os_str().as_bytes())
+                    .expect("invalid path");
 
-                assert_eq!(
-                    cef_load_library(framework_dir.as_os_str().as_bytes().as_ptr().cast()),
-                    1
-                );
+                assert_eq!(cef_load_library(framework_dir.as_ptr().cast()), 1);
             }
 
             assert_eq!(cef_initialize(null(), null(), null_mut(), null_mut()), 0);