chore: Use Rust's `OnceCell`/`OnceLock`

They were stabilized in Rust 1.70.0, which was released yesterday.
This removes the `once_cell` dependency.

Cargo.lock

@@ -3713,7 +3713,6 @@ dependencies = [
  "nellymoser-rs",
  "num-derive",
  "num-traits",
- "once_cell",
  "percent-encoding",
  "quick-xml",
  "rand",
@@ -3864,7 +3863,6 @@ dependencies = [
  "naga",
  "naga-agal",
  "naga_oil",
- "once_cell",
  "ouroboros",
  "profiling",
  "raw-window-handle",
@@ -4522,7 +4520,6 @@ dependencies = [
  "futures",
  "image",
  "libtest-mimic",
- "once_cell",
  "pretty_assertions",
  "regex",
  "ruffle_core",

core/Cargo.toml

@@ -48,7 +48,6 @@ enumset = "1.1.2"
 bytemuck = "1.13.1"
 clap = { version = "4.3.0", features = ["derive"], optional=true }
 realfft = "3.3.0"
-once_cell = "1.17.1"
 hashbrown = { version = "0.13.2", features = ["raw"] }
 scopeguard = "1.1.0"
 fluent-templates = "0.8.0"

core/src/avm2/globals/flash/media/sound_mixer.rs

@@ -1,17 +1,13 @@
 //! `flash.media.SoundMixer` builtin/prototype
 
-use std::cell::RefMut;
-use std::sync::Arc;
-
 use crate::avm2::activation::Activation;
-use crate::avm2::bytearray::ByteArrayStorage;
 use crate::avm2::object::Object;
 use crate::avm2::object::TObject;
 use crate::avm2::value::Value;
 use crate::avm2::Error;
 use crate::avm2_stub_getter;
 use crate::display_object::SoundTransform;
-use once_cell::sync::Lazy;
+use std::sync::{Arc, OnceLock};
 
 /// Implements `soundTransform`'s getter
 ///
@@ -109,7 +105,7 @@ pub fn compute_spectrum<'gc>(
     args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error<'gc>> {
     let arg0 = args[0].as_object().unwrap();
-    let mut bytearray: RefMut<ByteArrayStorage> = arg0
+    let mut bytearray = arg0
         .as_bytearray_mut(activation.context.gc_context)
         .unwrap();
     let mut hist = activation.context.audio.get_sample_history();
@@ -122,11 +118,11 @@ pub fn compute_spectrum<'gc>(
     };
 
     if fft {
-        // Flash Player appears to do a 2048-long FFT with only the first 512 samples filled in...
-        static FFT: Lazy<Arc<dyn realfft::RealToComplex<f32>>> =
-            Lazy::new(|| realfft::RealFftPlanner::new().plan_fft_forward(2048));
+        // TODO: Use `std::sync::LazyLock` once it's stabilized?
+        static FFT: OnceLock<Arc<dyn realfft::RealToComplex<f32>>> = OnceLock::new();
 
-        let fft = FFT.as_ref();
+        // Flash Player appears to do a 2048-long FFT with only the first 512 samples filled in...
+        let fft = FFT.get_or_init(|| realfft::RealFftPlanner::new().plan_fft_forward(2048));
 
         let mut in_left = fft.make_input_vec();
         let mut in_right = fft.make_input_vec();

render/wgpu/Cargo.toml

@@ -21,7 +21,6 @@ image = { version = "0.24.6", default-features = false }
 naga_oil = "0.7.0"
 ouroboros = "0.15.6"
 typed-arena = "2.0.2"
-once_cell = "1.17.1"
 gc-arena = { workspace = true }
 naga-agal = { path = "../naga-agal" }
 downcast-rs = "1.2.0"

render/wgpu/src/lib.rs

@@ -14,11 +14,10 @@ use crate::utils::{
 use bytemuck::{Pod, Zeroable};
 use descriptors::Descriptors;
 use enum_map::Enum;
-use once_cell::sync::OnceCell;
 use ruffle_render::bitmap::{BitmapHandle, BitmapHandleImpl, PixelRegion, RgbaBufRead, SyncHandle};
 use ruffle_render::shape_utils::GradientType;
 use ruffle_render::tessellator::{Gradient as TessGradient, Vertex as TessVertex};
-use std::cell::Cell;
+use std::cell::{Cell, OnceCell};
 use std::sync::Arc;
 use swf::GradientSpread;
 pub use wgpu;

render/wgpu/src/surface/target.rs

@@ -5,8 +5,7 @@ use crate::globals::Globals;
 use crate::surface::commands::run_copy_pipeline;
 use crate::utils::create_buffer_with_data;
 use crate::Transforms;
-use once_cell::race::OnceBool;
-use once_cell::sync::OnceCell;
+use std::cell::OnceCell;
 use std::sync::Arc;
 
 #[derive(Debug)]
@@ -199,7 +198,7 @@ pub struct CommandTarget {
     format: wgpu::TextureFormat,
     sample_count: u32,
     whole_frame_bind_group: OnceCell<(wgpu::Buffer, wgpu::BindGroup)>,
-    color_needs_clear: OnceBool,
+    color_needs_clear: OnceCell<bool>,
     render_target_mode: RenderTargetMode,
 }
 
@@ -296,7 +295,7 @@ impl CommandTarget {
             format,
             sample_count,
             whole_frame_bind_group,
-            color_needs_clear: OnceBool::new(),
+            color_needs_clear: OnceCell::new(),
             render_target_mode,
         }
     }

tests/Cargo.toml

@@ -33,7 +33,6 @@ toml = "0.7.4"
 libtest-mimic = "0.6.0"
 walkdir = "2.3.2"
 anyhow = "1.0"
-once_cell = "1.17.0"
 
 [[test]]
 name = "tests"

tests/tests/util/environment.rs

@@ -1,8 +1,7 @@
-use once_cell::sync::Lazy;
 use ruffle_render_wgpu::backend::request_adapter_and_device;
 use ruffle_render_wgpu::descriptors::Descriptors;
 use ruffle_render_wgpu::wgpu;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 
 /*
    It can be expensive to construct WGPU, much less Descriptors, so we put it off as long as we can
@@ -35,4 +34,8 @@ fn build_wgpu_descriptors() -> Option<Arc<Descriptors>> {
     }
 }
 
-pub static WGPU: Lazy<Option<Arc<Descriptors>>> = Lazy::new(build_wgpu_descriptors);
+pub fn wgpu_descriptors() -> Option<&'static Arc<Descriptors>> {
+    // TODO: Use `std::sync::LazyLock` once it's stabilized?
+    static WGPU: OnceLock<Option<Arc<Descriptors>>> = OnceLock::new();
+    WGPU.get_or_init(build_wgpu_descriptors).as_ref()
+}

tests/tests/util/options.rs

@@ -1,4 +1,4 @@
-use crate::util::environment::WGPU;
+use crate::util::environment::wgpu_descriptors;
 use crate::util::runner::TestAudioBackend;
 use anyhow::{anyhow, Result};
 use approx::assert_relative_eq;
@@ -121,7 +121,7 @@ impl PlayerOptions {
             use ruffle_render_wgpu::backend::WgpuRenderBackend;
             use ruffle_render_wgpu::target::TextureTarget;
 
-            if let Some(descriptors) = WGPU.clone() {
+            if let Some(descriptors) = wgpu_descriptors() {
                 if render_options.is_supported(&descriptors.adapter) {
                     let target = TextureTarget::new(&descriptors.device, (width, height))
                         .map_err(|e| anyhow!(e.to_string()))?;
@@ -135,7 +135,7 @@ impl PlayerOptions {
                             _ => StageQuality::Low,
                         })
                         .with_renderer(
-                            WgpuRenderBackend::new(descriptors, target)
+                            WgpuRenderBackend::new(descriptors.clone(), target)
                                 .map_err(|e| anyhow!(e.to_string()))?,
                         );
                 }
@@ -160,8 +160,8 @@ impl PlayerOptions {
             // If we don't actually want to check the renderer (ie we're just listing potential tests),
             // don't spend the cost to create it
             if check_renderer && !render.optional {
-                if let Some(wgpu) = WGPU.as_deref() {
-                    if !render.is_supported(&wgpu.adapter) {
+                if let Some(descriptors) = wgpu_descriptors() {
+                    if !render.is_supported(&descriptors.adapter) {
                         return false;
                     }
                 } else {
@@ -192,7 +192,7 @@ impl ImageComparison {
         actual_image: image::RgbaImage,
         expected_image: image::RgbaImage,
         test_path: &Path,
-        adapter_info: ruffle_render_wgpu::wgpu::AdapterInfo,
+        adapter_info: wgpu::AdapterInfo,
     ) -> Result<()> {
         use anyhow::Context;
 

tests/tests/util/runner.rs

@@ -183,7 +183,7 @@ pub fn run_swf(
     // FIXME: Determine how we want to compare against on on-disk image
     #[cfg(feature = "imgtests")]
     if let Some(image_comparison) = &test.options.image_comparison {
-        if crate::util::environment::WGPU.is_some() {
+        if crate::util::environment::wgpu_descriptors().is_some() {
             use anyhow::Context;
             use ruffle_render_wgpu::backend::WgpuRenderBackend;
             use ruffle_render_wgpu::target::TextureTarget;