Merge pull request #124 from wravery/dev

chore(deps): update CEF version to 137.0.19

Author: wravery

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 members = ["download-cef", "update-bindings", "export-cef-dir", "sys", "cef"]
 
 [workspace.package]
-version = "137.0.1+137.0.8"
+version = "137.1.0+137.0.19"
 edition = "2021"
 license = "Apache-2.0 OR MIT"
 authors = [
@@ -15,8 +15,8 @@ authors = [
 repository = "https://github.com/tauri-apps/cef-rs"
 
 [workspace.dependencies]
-cef-dll-sys = { version = "137.0.1", path = "sys" }
-download-cef = { version = "1.4.1", path = "download-cef" }
+cef-dll-sys = { version = "137.1.0", path = "sys" }
+download-cef = { version = "1.5.0", path = "download-cef" }
 
 anyhow = "1"
 bindgen = "0.72"

download-cef/Cargo.toml

@@ -1,21 +1,21 @@
 [package]
 name = "download-cef"
 description = "Download and extract pre-built CEF (Chromium Embedded Framework) archives."
-version = "1.4.1"
+version = "1.5.0"
 
 edition.workspace = true
 license.workspace = true
 authors.workspace = true
 repository.workspace = true
 
 [dependencies]
+regex.workspace = true
 semver.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 thiserror.workspace = true
 
-bzip2 = { version = "0.5", default-features = false, features = [
-    "libbz2-rs-sys",
-] }
+bzip2 = "0.6"
 indicatif = "0.17"
 sha1_smol = "1"
 tar = "0.4"

download-cef/src/lib.rs

@@ -1,16 +1,17 @@
 #![doc = include_str!("../README.md")]
 
 use bzip2::bufread::BzDecoder;
+use regex::Regex;
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use sha1_smol::Sha1;
 use std::{
     collections::HashMap,
     fmt::{self, Display},
     fs::{self, File},
-    io::{self, BufReader, IsTerminal},
+    io::{self, BufReader, IsTerminal, Write},
     path::{Path, PathBuf},
-    sync::Mutex,
+    sync::{Mutex, OnceLock},
 };
 
 #[macro_use]
@@ -40,6 +41,18 @@ pub enum Error {
     CorruptedFile(String),
     #[error("Invalid archive file path: {0}")]
     InvalidArchiveFile(String),
+    #[error("JSON serialization error: {0}")]
+    Json(#[from] serde_json::Error),
+    #[error(
+        "Undexpected archive version: location: {location} archive {archive} expected {expected}"
+    )]
+    VersionMismatch {
+        location: String,
+        archive: String,
+        expected: String,
+    },
+    #[error("Invalid regex pattern: {0}")]
+    InvalidRegexPattern(#[from] regex::Error),
 }
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -59,21 +72,55 @@ pub const WINDOWS_TARGETS: &[&str] = &[
 ];
 
 pub fn default_version(version: &str) -> String {
-    static VERSIONS: Mutex<Option<HashMap<String, String>>> = Mutex::new(None);
-    let mut versions = VERSIONS.lock().expect("Lock error");
-    if versions.is_none() {
-        *versions = Some(HashMap::new());
-    };
-    let versions = versions.as_mut().unwrap();
-    versions
-        .entry(version.to_string())
-        .or_insert_with(|| {
-            Version::parse(version)
-                .ok()
-                .and_then(|version| (!version.build.is_empty()).then(|| version.build.to_string()))
-                .unwrap_or_else(|| version.to_string())
+    unwrap_cef_version(version).unwrap_or_else(|_| version.to_string())
+}
+
+fn unwrap_cef_version(version: &str) -> Result<String> {
+    static VERSIONS: OnceLock<Mutex<HashMap<Version, String>>> = OnceLock::new();
+    let mut versions = VERSIONS
+        .get_or_init(Default::default)
+        .lock()
+        .expect("Lock error");
+    Ok(versions
+        .entry(Version::parse(version)?)
+        .or_insert_with_key(|v| {
+            if v.build.is_empty() {
+                version.to_string()
+            } else {
+                v.build.to_string()
+            }
+        })
+        .clone())
+}
+
+pub fn check_archive_json(version: &str, location: &str) -> Result<()> {
+    let expected = Version::parse(&unwrap_cef_version(version)?)?;
+
+    static PATTERN: OnceLock<core::result::Result<Regex, regex::Error>> = OnceLock::new();
+    let pattern = PATTERN
+        .get_or_init(|| Regex::new(r"^cef_binary_([^+]+)(:?\+.+)?$"))
+        .as_ref()
+        .map_err(Clone::clone)?;
+    let archive_json: CefFile = serde_json::from_reader(File::open(archive_json_path(location))?)?;
+    let archive_version = pattern.replace(&archive_json.name, "$1");
+    let archive = Version::parse(&archive_version)?;
+
+    if archive == expected {
+        Ok(())
+    } else {
+        Err(Error::VersionMismatch {
+            location: location.to_string(),
+            expected: expected.to_string(),
+            archive: archive.to_string(),
         })
-        .clone()
+    }
+}
+
+fn archive_json_path<P>(location: P) -> PathBuf
+where
+    P: AsRef<Path>,
+{
+    location.as_ref().join("archive.json")
 }
 
 const URL: &str = "https://cef-builds.spotifycdn.com";
@@ -231,6 +278,16 @@ impl CefVersion {
             .find(|f| f.file_type == "minimal")
             .ok_or_else(|| Error::VersionNotFound(self.cef_version.clone()))
     }
+
+    pub fn write_archive_json<P>(&self, location: P) -> Result<()>
+    where
+        P: AsRef<Path>,
+    {
+        let archive_version = serde_json::to_string_pretty(self.minimal()?)?;
+        let mut archive_json = File::create(archive_json_path(location))?;
+        archive_json.write_all(archive_version.as_bytes())?;
+        Ok(())
+    }
 }
 
 #[derive(Deserialize, Serialize)]

export-cef-dir/src/main.rs

@@ -2,12 +2,7 @@
 
 use clap::Parser;
 use download_cef::{CefIndex, OsAndArch, DEFAULT_TARGET};
-use std::{
-    fs::{self, File},
-    io::Write,
-    path::PathBuf,
-    sync::OnceLock,
-};
+use std::{fs, path::PathBuf, sync::OnceLock};
 
 fn default_version() -> &'static str {
     static DEFAULT_VERSION: OnceLock<String> = OnceLock::new();
@@ -91,11 +86,7 @@ fn main() -> anyhow::Result<()> {
         fs::remove_file(archive)?;
     }
 
-    {
-        let archive_version = serde_json::to_string_pretty(version.minimal()?)?;
-        let mut archive_json = File::create(extracted_dir.join("archive.json"))?;
-        archive_json.write_all(archive_version.as_bytes())?;
-    }
+    version.write_archive_json(extracted_dir)?;
 
     if output != cef_dir {
         println!("Renaming: {}", output.display());

sys/Cargo.toml

@@ -16,7 +16,7 @@ doctest = false
 dox = []
 
 [package.metadata.docs.rs]
-features = [ "dox" ]
+features = ["dox"]
 
 [build-dependencies]
 anyhow.workspace = true

sys/build.rs

@@ -1,12 +1,7 @@
 #[cfg(not(feature = "dox"))]
 fn main() -> anyhow::Result<()> {
     use download_cef::{CefIndex, OsAndArch};
-    use std::{
-        env,
-        fs::{self, File},
-        io::Write,
-        path::PathBuf,
-    };
+    use std::{env, fs, path::PathBuf};
 
     println!("cargo::rerun-if-changed=build.rs");
 
@@ -23,6 +18,7 @@ fn main() -> anyhow::Result<()> {
         Ok(cef_path) => {
             // Allow overriding the CEF path with environment variables.
             println!("Using CEF path from environment: {cef_path}");
+            download_cef::check_archive_json(&env::var("CARGO_PKG_VERSION")?, &cef_path)?;
             PathBuf::from(cef_path)
         }
         Err(_) => {
@@ -45,9 +41,7 @@ fn main() -> anyhow::Result<()> {
                     ));
                 }
 
-                let archive_version = serde_json::to_string_pretty(version.minimal()?)?;
-                let mut archive_json = File::create(extracted_dir.join("archive.json"))?;
-                archive_json.write_all(archive_version.as_bytes())?;
+                version.write_archive_json(extracted_dir)?;
             }
 
             cef_dir