avm1: Don't store owned strings in ActivationIdentifier

We can instead always store a `&'a str`.

Author: moulins

core/src/avm1/activation.rs

@@ -20,7 +20,6 @@ use gc_arena::{Gc, Mutation};
 use indexmap::IndexMap;
 use rand::Rng;
 use ruffle_macros::istr;
-use std::borrow::Cow;
 use std::cell::Cell;
 use std::cmp::min;
 use std::fmt;
@@ -63,7 +62,7 @@ enum FrameControl<'gc> {
 #[derive(Clone)]
 pub struct ActivationIdentifier<'a> {
     parent: Option<&'a ActivationIdentifier<'a>>,
-    name: Cow<'static, str>,
+    name: &'a str,
     depth: u16,
     function_count: u16,
     special_count: u8,
@@ -75,36 +74,36 @@ impl fmt::Display for ActivationIdentifier<'_> {
             write!(f, "{parent} / ")?;
         }
 
-        f.write_str(&self.name)?;
+        f.write_str(self.name)?;
 
         Ok(())
     }
 }
 
 impl<'a> ActivationIdentifier<'a> {
-    pub fn root<S: Into<Cow<'static, str>>>(name: S) -> Self {
+    pub fn root(name: &'a str) -> Self {
         Self {
             parent: None,
-            name: name.into(),
+            name,
             depth: 0,
             function_count: 0,
             special_count: 0,
         }
     }
 
-    pub fn child<S: Into<Cow<'static, str>>>(&'a self, name: S) -> Self {
+    pub fn child(&'a self, name: &'a str) -> Self {
         Self {
             parent: Some(self),
-            name: name.into(),
+            name,
             depth: self.depth + 1,
             function_count: self.function_count,
             special_count: self.special_count,
         }
     }
 
-    pub fn function<'gc, S: Into<Cow<'static, str>>>(
+    pub fn function<'gc>(
         &'a self,
-        name: S,
+        name: &'a str,
         reason: ExecutionReason,
         max_recursion_depth: u16,
     ) -> Result<Self, Error<'gc>> {
@@ -124,7 +123,7 @@ impl<'a> ActivationIdentifier<'a> {
         };
         Ok(Self {
             parent: Some(self),
-            name: name.into(),
+            name,
             depth: self.depth + 1,
             function_count,
             special_count,
@@ -247,9 +246,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     /// Create a new activation to run a block of code with a given scope.
-    pub fn with_new_scope<'b, S: Into<Cow<'static, str>>>(
+    pub fn with_new_scope<'b>(
         &'b mut self,
-        name: S,
+        name: &'b str,
         scope: Gc<'gc, Scope<'gc>>,
     ) -> Activation<'b, 'gc> {
         let id = self.id.child(name);
@@ -329,9 +328,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     /// Add a stack frame that executes code in timeline scope
-    pub fn run_child_frame_for_action<S: Into<Cow<'static, str>>>(
+    pub fn run_child_frame_for_action(
         &mut self,
-        name: S,
+        name: &str,
         active_clip: DisplayObject<'gc>,
         code: SwfSlice,
     ) -> Result<ReturnType<'gc>, Error<'gc>> {
@@ -365,9 +364,9 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     /// Add a stack frame that executes code in initializer scope.
-    pub fn run_with_child_frame_for_display_object<F, R, S: Into<Cow<'static, str>>>(
+    pub fn run_with_child_frame_for_display_object<F, R>(
         &mut self,
-        name: S,
+        name: &str,
         active_clip: DisplayObject<'gc>,
         swf_version: u8,
         function: F,

core/src/avm1/function.rs

@@ -348,7 +348,7 @@ impl<'gc> Avm1Function<'gc> {
         let max_recursion_depth = activation.context.avm1.max_recursion_depth();
         let mut frame = Activation::from_action(
             activation.context,
-            activation.id.function(name, reason, max_recursion_depth)?,
+            activation.id.function(&name, reason, max_recursion_depth)?,
             swf_version,
             child_scope,
             self.constant_pool,

core/src/avm1/runtime.rs

@@ -12,7 +12,6 @@ use crate::string::{AvmString, StringContext};
 use crate::tag_utils::SwfSlice;
 use crate::{avm1, avm_debug};
 use gc_arena::{Collect, Gc, Mutation};
-use std::borrow::Cow;
 use swf::avm1::read::Reader;
 use tracing::instrument;
 
@@ -136,9 +135,9 @@ impl<'gc> Avm1<'gc> {
     /// Add a stack frame that executes code in timeline scope
     ///
     /// This creates a new frame stack.
-    pub fn run_stack_frame_for_action<S: Into<Cow<'static, str>>>(
+    pub fn run_stack_frame_for_action(
         active_clip: DisplayObject<'gc>,
-        name: S,
+        name: &str,
         code: SwfSlice,
         context: &mut UpdateContext<'gc>,
     ) {
@@ -284,11 +283,9 @@ impl<'gc> Avm1<'gc> {
             return;
         }
 
-        let mut activation = Activation::from_nothing(
-            context,
-            ActivationIdentifier::root(name.to_string()),
-            active_clip,
-        );
+        let name_utf8 = &name.to_utf8_lossy();
+        let mut activation =
+            Activation::from_nothing(context, ActivationIdentifier::root(name_utf8), active_clip);
 
         let _ = obj.call_method(name, args, &mut activation, ExecutionReason::Special);
     }

core/src/streams.rs

@@ -1369,11 +1369,12 @@ impl<'gc> NetStream<'gc> {
         match avm_object {
             Some(NetStreamKind::Avm1(object)) => {
                 let avm_string_name = AvmString::new_utf8_bytes(context.gc(), variable_name);
+                let activation_name = format!("[FLV {avm_string_name}]");
 
                 let root = context.stage.root_clip().expect("root");
                 let mut activation = Avm1Activation::from_nothing(
                     context,
-                    Avm1ActivationIdentifier::root(format!("[FLV {avm_string_name}]")),
+                    Avm1ActivationIdentifier::root(&activation_name),
                     root,
                 );