chore: migrate web/* crates to edition 2024

The `obj2` crate now causes a warning ("unexpected `cfg` condition value: `cargo-clippy`")
and is unmaintained, so this switches to the better-maintained `objc2` fork
(https://github.com/madsmtm/objc2).

Author: moulins

Cargo.lock

@@ -2,7 +2,7 @@
 name = "ruffle_web"
 description = "Web (WASM) bindings to the Ruffle Flash player"
 authors.workspace = true
-edition.workspace = true
+edition = "2024"
 homepage.workspace = true
 license.workspace = true
 repository.workspace = true

web/Cargo.toml

@@ -2,7 +2,7 @@
 name = "ruffle_web_common"
 version.workspace = true
 authors.workspace = true
-edition.workspace = true
+edition = "2024"
 license.workspace = true
 
 [lints]

web/common/Cargo.toml

@@ -2,7 +2,7 @@
 name = "ruffle_web_safari"
 description = "Native binary for the Safari Web Extension"
 authors.workspace = true
-edition.workspace = true
+edition = "2024"
 homepage.workspace = true
 license.workspace = true
 repository.workspace = true
@@ -12,5 +12,5 @@ publish = false # This crate is useless unless packaged into an appex bundle
 [lints]
 workspace = true
 
-[dependencies]
-objc = "0.2.7"
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = "0.6.3"

web/packages/extension/safari/Cargo.toml

@@ -1,23 +1,22 @@
 #[cfg(target_os = "macos")]
 mod macos {
-    use objc::class;
-    use objc::declare::ClassDecl;
-    use objc::runtime::Protocol;
+    use objc2::class;
+    use objc2::runtime::{AnyProtocol, ClassBuilder};
 
     pub fn extension_class() {
-        let mut ruffle = ClassDecl::new("RuffleWebExtension", class!(NSObject))
-            .expect("Couldn't allocate new ClassDecl");
+        let mut ruffle = ClassBuilder::new(c"RuffleWebExtension", class!(NSObject))
+            .expect("Couldn't allocate new class");
 
         ruffle.add_protocol(
-            Protocol::get("NSExtensionRequestHandling")
+            AnyProtocol::get(c"NSExtensionRequestHandling")
                 .expect("Couldn't find NSExtensionRequestHandling"),
         );
 
         ruffle.register();
     }
 
     #[link(name = "Foundation", kind = "framework")]
-    extern "C" {
+    unsafe extern "C" {
         /// Private function used as the entry point of all app extensions.
         ///
         /// In Obj-C/Swift apps, a linker flag is used to set this as the entry

web/packages/extension/safari/src/main.rs

@@ -1,15 +1,15 @@
 use ruffle_core::backend::audio::{
-    swf, AudioBackend, AudioMixer, AudioMixerProxy, DecodeError, RegisterError, SoundHandle,
-    SoundInstanceHandle, SoundStreamInfo, SoundTransform,
+    AudioBackend, AudioMixer, AudioMixerProxy, DecodeError, RegisterError, SoundHandle,
+    SoundInstanceHandle, SoundStreamInfo, SoundTransform, swf,
 };
 use ruffle_core::impl_audio_mixer_backend;
 use ruffle_web_common::JsResult;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::sync::Arc;
 use std::time::Duration;
-use tracing_subscriber::layer::Layered;
 use tracing_subscriber::Registry;
+use tracing_subscriber::layer::Layered;
 use tracing_wasm::WASMLayer;
 use wasm_bindgen::prelude::*;
 use web_sys::{AudioContext, AudioScheduledSourceNode};
@@ -257,7 +257,7 @@ impl Drop for Buffer {
 }
 
 #[wasm_bindgen(raw_module = "./ruffle-imports")]
-extern "C" {
+unsafe extern "C" {
     // Imported JS method to copy interleaved audio data into an `AudioBuffer`.
     #[wasm_bindgen(js_name = "copyToAudioBufferInterleaved")]
     fn copy_to_audio_buffer_interleaved(

web/src/audio.rs

@@ -1,8 +1,8 @@
 use crate::external_interface::JavascriptInterface;
 use crate::navigator::{OpenUrlMode, WebNavigatorBackend};
 use crate::{
-    audio, log_adapter, storage, ui, JavascriptPlayer, RuffleHandle, ScrollingBehavior,
-    SocketProxy, RUFFLE_GLOBAL_PANIC,
+    JavascriptPlayer, RUFFLE_GLOBAL_PANIC, RuffleHandle, ScrollingBehavior, SocketProxy, audio,
+    log_adapter, storage, ui,
 };
 use js_sys::{Promise, RegExp};
 use ruffle_core::backend::audio::{AudioBackend, NullAudioBackend};
@@ -12,9 +12,9 @@ use ruffle_core::compatibility_rules::CompatibilityRules;
 use ruffle_core::config::{Letterbox, NetworkingAccessMode};
 use ruffle_core::events::{GamepadButton, KeyCode};
 use ruffle_core::{
-    swf, Color, DefaultFont, Player, PlayerBuilder, PlayerRuntime, StageAlign, StageScaleMode,
+    Color, DefaultFont, Player, PlayerBuilder, PlayerRuntime, StageAlign, StageScaleMode, swf,
 };
-use ruffle_core::{ttf_parser, FontFileData};
+use ruffle_core::{FontFileData, ttf_parser};
 use ruffle_render::backend::RenderBackend;
 use ruffle_render::quality::StageQuality;
 use ruffle_video_external::backend::ExternalVideoBackend;
@@ -27,8 +27,8 @@ use std::rc::Rc;
 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use tracing_subscriber::layer::{Layered, SubscriberExt};
 use tracing_subscriber::Registry;
+use tracing_subscriber::layer::{Layered, SubscriberExt};
 use tracing_wasm::{WASMLayer, WASMLayerConfigBuilder};
 use wasm_bindgen::prelude::*;
 use web_sys::{HtmlCanvasElement, HtmlElement};
@@ -391,49 +391,48 @@ impl RuffleInstanceBuilder {
                 }
             } else {
                 tracing::debug!("Loading font {font_name} as SWF font");
-                if let Ok(swf_stream) = swf::decompress_swf(&bytes[..]) {
-                    if let Ok(swf) = swf::parse_swf(&swf_stream) {
-                        let encoding = swf::SwfStr::encoding_for_version(swf.header.version());
-                        for tag in swf.tags {
-                            match tag {
-                                swf::Tag::DefineFont(_font) => {
-                                    tracing::warn!("DefineFont1 tag is not yet supported by Ruffle, inside font swf {font_name}");
-                                }
-                                swf::Tag::DefineFont2(font) => {
-                                    tracing::debug!(
-                                        "Loaded font {} from font swf {font_name}",
-                                        font.name.to_str_lossy(encoding)
+                if let Ok(swf_stream) = swf::decompress_swf(&bytes[..])
+                    && let Ok(swf) = swf::parse_swf(&swf_stream)
+                {
+                    let encoding = swf::SwfStr::encoding_for_version(swf.header.version());
+                    for tag in swf.tags {
+                        match tag {
+                            swf::Tag::DefineFont(_font) => {
+                                tracing::warn!(
+                                    "DefineFont1 tag is not yet supported by Ruffle, inside font swf {font_name}"
+                                );
+                            }
+                            swf::Tag::DefineFont2(font) => {
+                                tracing::debug!(
+                                    "Loaded font {} from font swf {font_name}",
+                                    font.name.to_str_lossy(encoding)
+                                );
+                                player
+                                    .register_device_font(FontDefinition::SwfTag(*font, encoding));
+                            }
+                            swf::Tag::DefineFont4(font) => {
+                                let name = font.name.to_str_lossy(encoding);
+                                if let Some(data) = font.data {
+                                    tracing::debug!("Loaded font {name} from font swf {font_name}");
+                                    player.register_device_font(FontDefinition::FontFile {
+                                        name: name.to_string(),
+                                        is_bold: font.is_bold,
+                                        is_italic: font.is_italic,
+                                        // TODO remove when https://github.com/rust-lang/rust-clippy/issues/15252 is fixed
+                                        #[expect(clippy::unnecessary_to_owned)]
+                                        data: FontFileData::new(data.to_vec()),
+                                        index: 0,
+                                    })
+                                } else {
+                                    tracing::warn!(
+                                        "Font {name} from font swf {font_name} contains no data"
                                     );
-                                    player.register_device_font(FontDefinition::SwfTag(
-                                        *font, encoding,
-                                    ));
-                                }
-                                swf::Tag::DefineFont4(font) => {
-                                    let name = font.name.to_str_lossy(encoding);
-                                    if let Some(data) = font.data {
-                                        tracing::debug!(
-                                            "Loaded font {name} from font swf {font_name}"
-                                        );
-                                        player.register_device_font(FontDefinition::FontFile {
-                                            name: name.to_string(),
-                                            is_bold: font.is_bold,
-                                            is_italic: font.is_italic,
-                                            // TODO remove when https://github.com/rust-lang/rust-clippy/issues/15252 is fixed
-                                            #[expect(clippy::unnecessary_to_owned)]
-                                            data: FontFileData::new(data.to_vec()),
-                                            index: 0,
-                                        })
-                                    } else {
-                                        tracing::warn!(
-                                            "Font {name} from font swf {font_name} contains no data"
-                                        );
-                                    }
                                 }
-                                _ => {}
                             }
+                            _ => {}
                         }
-                        continue;
                     }
+                    continue;
                 }
                 tracing::warn!("Font source {font_name} was not recognised (not a valid SWF?)");
             }

web/src/builder.rs

@@ -1,4 +1,4 @@
-use crate::{JavascriptPlayer, CURRENT_CONTEXT};
+use crate::{CURRENT_CONTEXT, JavascriptPlayer};
 use js_sys::{Array, Object};
 use ruffle_core::context::UpdateContext;
 use ruffle_core::external::{
@@ -89,10 +89,10 @@ pub fn js_to_external_value(js: &JsValue) -> ExternalValue {
     } else {
         let mut values = BTreeMap::new();
         for entry in Object::entries(&Object::from(js.to_owned())).values() {
-            if let Ok(entry) = entry.and_then(|v| v.dyn_into::<Array>()) {
-                if let Some(key) = entry.get(0).as_string() {
-                    values.insert(key, js_to_external_value(&entry.get(1)));
-                }
+            if let Ok(entry) = entry.and_then(|v| v.dyn_into::<Array>())
+                && let Some(key) = entry.get(0).as_string()
+            {
+                values.insert(key, js_to_external_value(&entry.get(1)));
             }
         }
         ExternalValue::Object(values)

web/src/external_interface.rs

@@ -22,7 +22,7 @@ use ruffle_core::tag_utils::SwfMovie;
 use ruffle_core::{Player, PlayerEvent, StaticCallstack, ViewportDimensions};
 use ruffle_web_common::JsResult;
 use serde::Serialize;
-use slotmap::{new_key_type, SlotMap};
+use slotmap::{SlotMap, new_key_type};
 use std::any::Any;
 use std::rc::Rc;
 use std::str::FromStr;
@@ -147,7 +147,7 @@ struct RuffleInstance {
 }
 
 #[wasm_bindgen(raw_module = "./internal/player/inner")]
-extern "C" {
+unsafe extern "C" {
     #[derive(Clone)]
     pub type JavascriptPlayer;
 
@@ -159,7 +159,7 @@ extern "C" {
 
     #[wasm_bindgen(method, catch, js_name = "callFSCommand")]
     fn call_fs_command(this: &JavascriptPlayer, command: &str, args: &str)
-        -> Result<bool, JsValue>;
+    -> Result<bool, JsValue>;
 
     #[wasm_bindgen(method)]
     fn panic(this: &JavascriptPlayer, error: &JsError);
@@ -1110,57 +1110,54 @@ impl RuffleHandle {
                 ));
             }
 
-            if let Ok(gamepads) = instance.window.navigator().get_gamepads() {
-                if let Some(gamepad) = gamepads
-                    .into_iter()
-                    .next()
-                    .and_then(|gamepad| gamepad.dyn_into::<WebGamepad>().ok())
-                {
-                    let mut pressed_buttons = Vec::new();
-
-                    let buttons = gamepad.buttons();
-                    for (index, button) in buttons.into_iter().enumerate() {
-                        let Ok(button) = button.dyn_into::<WebGamepadButton>() else {
-                            continue;
-                        };
+            if let Ok(gamepads) = instance.window.navigator().get_gamepads()
+                && let Some(gamepad) = gamepads.into_iter().next()
+                && let Ok(gamepad) = gamepad.dyn_into::<WebGamepad>()
+            {
+                let mut pressed_buttons = Vec::new();
 
-                        if !button.pressed() {
-                            continue;
-                        }
+                let buttons = gamepad.buttons();
+                for (index, button) in buttons.into_iter().enumerate() {
+                    let Ok(button) = button.dyn_into::<WebGamepadButton>() else {
+                        continue;
+                    };
 
-                        // See https://w3c.github.io/gamepad/#remapping
-                        let gamepad_button = match index {
-                            0 => GamepadButton::South,
-                            1 => GamepadButton::East,
-                            2 => GamepadButton::West,
-                            3 => GamepadButton::North,
-                            12 => GamepadButton::DPadUp,
-                            13 => GamepadButton::DPadDown,
-                            14 => GamepadButton::DPadLeft,
-                            15 => GamepadButton::DPadRight,
-                            _ => continue,
-                        };
-
-                        pressed_buttons.push(gamepad_button);
+                    if !button.pressed() {
+                        continue;
                     }
 
-                    if pressed_buttons != instance.pressed_buttons {
-                        for button in pressed_buttons.iter() {
-                            if !instance.pressed_buttons.contains(button) {
-                                gamepad_button_events
-                                    .push(PlayerEvent::GamepadButtonDown { button: *button });
-                            }
-                        }
+                    // See https://w3c.github.io/gamepad/#remapping
+                    let gamepad_button = match index {
+                        0 => GamepadButton::South,
+                        1 => GamepadButton::East,
+                        2 => GamepadButton::West,
+                        3 => GamepadButton::North,
+                        12 => GamepadButton::DPadUp,
+                        13 => GamepadButton::DPadDown,
+                        14 => GamepadButton::DPadLeft,
+                        15 => GamepadButton::DPadRight,
+                        _ => continue,
+                    };
+
+                    pressed_buttons.push(gamepad_button);
+                }
 
-                        for button in instance.pressed_buttons.iter() {
-                            if !pressed_buttons.contains(button) {
-                                gamepad_button_events
-                                    .push(PlayerEvent::GamepadButtonUp { button: *button });
-                            }
+                if pressed_buttons != instance.pressed_buttons {
+                    for button in pressed_buttons.iter() {
+                        if !instance.pressed_buttons.contains(button) {
+                            gamepad_button_events
+                                .push(PlayerEvent::GamepadButtonDown { button: *button });
                         }
+                    }
 
-                        instance.pressed_buttons = pressed_buttons;
+                    for button in instance.pressed_buttons.iter() {
+                        if !pressed_buttons.contains(button) {
+                            gamepad_button_events
+                                .push(PlayerEvent::GamepadButtonUp { button: *button });
+                        }
                     }
+
+                    instance.pressed_buttons = pressed_buttons;
                 }
             }
 
@@ -1306,10 +1303,10 @@ fn parse_movie_parameters(input: &JsValue) -> Vec<(String, String)> {
     let mut params = Vec::new();
     if let Ok(keys) = js_sys::Reflect::own_keys(input) {
         for key in keys.values().into_iter().flatten() {
-            if let Ok(value) = js_sys::Reflect::get(input, &key) {
-                if let (Some(key), Some(value)) = (key.as_string(), value.as_string()) {
-                    params.push((key, value))
-                }
+            if let Ok(value) = js_sys::Reflect::get(input, &key)
+                && let (Some(key), Some(value)) = (key.as_string(), value.as_string())
+            {
+                params.push((key, value))
             }
         }
     }