avm1: Migrate StageObject to a native object

Author: moulins

core/src/avm1.rs

@@ -32,7 +32,6 @@ pub use globals::array::ArrayBuilder;
 pub use globals::context_menu::make_context_menu_state;
 pub use globals::sound::start as start_sound;
 pub use object::script_object::ScriptObject;
-pub use object::stage_object::StageObject;
 pub use object::{NativeObject, Object, ObjectPtr, TObject};
 pub use property::Attribute;
 pub use property_map::PropertyMap;

core/src/avm1/activation.rs

@@ -582,7 +582,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
     }
 
     fn stack_push(&mut self, mut value: Value<'gc>) {
-        if let Value::Object(Object::StageObject(s)) = value {
+        if let Value::Object(obj) = value {
             // Note that there currently exists a subtle issue with this logic:
             // If the cached `Object` in a `MovieClipReference` becomes invalidated, causing it to switch back to path-based object resolution,
             // it should *never* switch back to cache-based resolution
@@ -591,7 +591,7 @@ impl<'a, 'gc> Activation<'a, 'gc> {
             // Fixing this will require a thorough refactor of AVM1 to store `Either<MovieClipReference, Object>
             // can refer to a MovieClip
             // There is a ignored test for this issue of "reference laundering" at "avm1/string_paths_reference_launder"
-            if let Some(mcr) = MovieClipReference::try_from_stage_object(self, s) {
+            if let Some(mcr) = MovieClipReference::try_from_stage_object(self, obj) {
                 value = Value::MovieClip(mcr);
             }
         }

core/src/avm1/globals/transform.rs

@@ -24,10 +24,7 @@ impl<'gc> TransformObject<'gc> {
         let clip = match args {
             // `Transform` constructor accepts exactly 1 argument.
             [Value::MovieClip(clip)] => Some(*clip),
-            [Value::Object(clip)] => {
-                let stage_object = clip.as_stage_object()?;
-                MovieClipReference::try_from_stage_object(activation, stage_object)
-            }
+            [Value::Object(clip)] => MovieClipReference::try_from_stage_object(activation, *clip),
             _ => return None,
         };
         Some(Self { clip })

core/src/avm1/object.rs

@@ -21,10 +21,11 @@ use crate::avm1::globals::transform::TransformObject;
 use crate::avm1::globals::xml::Xml;
 use crate::avm1::globals::xml_socket::XmlSocket;
 use crate::avm1::object::super_object::SuperObject;
-use crate::avm1::{Activation, Attribute, Error, ScriptObject, StageObject, Value};
+use crate::avm1::{Activation, Attribute, Error, ScriptObject, Value};
 use crate::bitmap::bitmap_data::BitmapDataWrapper;
-use crate::display_object::DisplayObject;
-use crate::display_object::TDisplayObject;
+use crate::display_object::{
+    Avm1Button, DisplayObject, EditText, MovieClip, TDisplayObject as _, Video,
+};
 use crate::html::TextFormat;
 use crate::streams::NetStream;
 use crate::string::AvmString;
@@ -59,6 +60,11 @@ pub enum NativeObject<'gc> {
     Array(()),
     Function(Gc<'gc, FunctionObject<'gc>>),
 
+    MovieClip(MovieClip<'gc>),
+    Button(Avm1Button<'gc>),
+    EditText(EditText<'gc>),
+    Video(Video<'gc>),
+
     Date(Gc<'gc, Cell<Date>>),
     BlurFilter(BlurFilter<'gc>),
     BevelFilter(BevelFilter<'gc>),
@@ -119,6 +125,18 @@ impl<'gc> BoxedF64<'gc> {
     }
 }
 
+impl<'gc> NativeObject<'gc> {
+    pub fn as_display_object(self) -> Option<DisplayObject<'gc>> {
+        match self {
+            Self::MovieClip(dobj) => Some(DisplayObject::MovieClip(dobj)),
+            Self::Button(dobj) => Some(DisplayObject::Avm1Button(dobj)),
+            Self::EditText(dobj) => Some(DisplayObject::EditText(dobj)),
+            Self::Video(dobj) => Some(DisplayObject::Video(dobj)),
+            _ => None,
+        }
+    }
+}
+
 /// Represents an object that can be directly interacted with by the AVM
 /// runtime.
 #[enum_trait_object(
@@ -127,7 +145,6 @@ impl<'gc> BoxedF64<'gc> {
     #[collect(no_drop)]
     pub enum Object<'gc> {
         ScriptObject(ScriptObject<'gc>),
-        StageObject(StageObject<'gc>),
         SuperObject(SuperObject<'gc>),
     }
 )]
@@ -323,10 +340,8 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Into<Object<'gc>> + Clone + Copy {
     ) -> Result<Value<'gc>, Error<'gc>> {
         let this = (*self).into();
 
-        if let Some(s) = this.as_stage_object() {
-            let d_o = s.as_display_object().unwrap();
-
-            if d_o.avm1_removed() {
+        if let Some(dobj) = this.as_display_object() {
+            if dobj.avm1_removed() {
                 return Ok(Value::Undefined);
             }
         }
@@ -608,11 +623,6 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Into<Object<'gc>> + Clone + Copy {
 
     fn set_native(&self, _gc_context: &Mutation<'gc>, _native: NativeObject<'gc>) {}
 
-    /// Get the underlying stage object, if it exists.
-    fn as_stage_object(&self) -> Option<StageObject<'gc>> {
-        None
-    }
-
     /// Get the underlying super object, if it exists.
     fn as_super_object(&self) -> Option<SuperObject<'gc>> {
         None
@@ -623,6 +633,11 @@ pub trait TObject<'gc>: 'gc + Collect<'gc> + Into<Object<'gc>> + Clone + Copy {
         None
     }
 
+    /// Get the underlying stage object, if it exists, but doesn't follow `super` objects.
+    fn as_display_object_no_super(&self) -> Option<DisplayObject<'gc>> {
+        None
+    }
+
     /// Get the underlying executable for this object, if it exists.
     fn as_executable(&self) -> Option<Executable<'gc>> {
         None

core/src/avm1/object/script_object.rs

@@ -1,14 +1,15 @@
 use crate::avm1::activation::Activation;
 use crate::avm1::error::Error;
 use crate::avm1::function::{Executable, ExecutionName, ExecutionReason};
-use crate::avm1::object::NativeObject;
+use crate::avm1::object::{stage_object, NativeObject};
 use crate::avm1::property::{Attribute, Property};
 use crate::avm1::property_map::{Entry, PropertyMap};
 use crate::avm1::{Object, ObjectPtr, TObject, Value};
+use crate::display_object::{DisplayObject, TDisplayObject as _};
 use crate::ecma_conversions::f64_to_wrapping_i32;
 use crate::string::{AvmString, StringContext};
 use core::fmt;
-use gc_arena::{Collect, GcCell, Mutation};
+use gc_arena::{Collect, GcCell, GcWeakCell, Mutation};
 use ruffle_macros::istr;
 
 #[derive(Clone, Collect)]
@@ -52,9 +53,27 @@ impl<'gc> Watcher<'gc> {
 #[collect(no_drop)]
 pub struct ScriptObject<'gc>(GcCell<'gc, ScriptObjectData<'gc>>);
 
+#[derive(Copy, Clone, Collect)]
+#[collect(no_drop)]
+pub struct ScriptObjectWeak<'gc>(GcWeakCell<'gc, ScriptObjectData<'gc>>);
+
+impl<'gc> ScriptObjectWeak<'gc> {
+    pub fn upgrade(self, mc: &Mutation<'gc>) -> Option<ScriptObject<'gc>> {
+        self.0.upgrade(mc).map(ScriptObject)
+    }
+}
+
+impl fmt::Debug for ScriptObjectWeak<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ScriptObjectWeak")
+            .field("ptr", &self.0.as_ptr())
+            .finish()
+    }
+}
+
 #[derive(Collect)]
 #[collect(no_drop)]
-pub struct ScriptObjectData<'gc> {
+struct ScriptObjectData<'gc> {
     native: NativeObject<'gc>,
     properties: PropertyMap<'gc, Property<'gc>>,
     interfaces: Vec<Object<'gc>>,
@@ -70,6 +89,10 @@ impl fmt::Debug for ScriptObject<'_> {
 }
 
 impl<'gc> ScriptObject<'gc> {
+    pub fn as_weak(self) -> ScriptObjectWeak<'gc> {
+        ScriptObjectWeak(GcCell::downgrade(self.0))
+    }
+
     pub fn new(context: &StringContext<'gc>, proto: Option<Object<'gc>>) -> Self {
         let object = Self(GcCell::new(
             context.gc(),
@@ -91,6 +114,16 @@ impl<'gc> ScriptObject<'gc> {
         object
     }
 
+    pub fn new_with_native(
+        context: &StringContext<'gc>,
+        proto: Option<Object<'gc>>,
+        native: NativeObject<'gc>,
+    ) -> Self {
+        let obj = Self::new(context, proto);
+        obj.set_native(context.gc(), native);
+        obj
+    }
+
     // Creates a ScriptObject, without assigning any __proto__ property.
     pub fn new_without_proto(gc_context: &Mutation<'gc>) -> Self {
         Self(GcCell::new(
@@ -170,14 +203,20 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
         &self,
         name: impl Into<AvmString<'gc>>,
         activation: &mut Activation<'_, 'gc>,
-        _is_slash_path: bool,
+        is_slash_path: bool,
     ) -> Option<Value<'gc>> {
-        self.0
-            .read()
-            .properties
-            .get(name.into(), activation.is_case_sensitive())
+        let name = name.into();
+        let read = self.0.read();
+
+        read.properties
+            .get(name, activation.is_case_sensitive())
             .filter(|property| property.allow_swf_version(activation.swf_version()))
             .map(|property| property.data())
+            .or_else(|| {
+                read.native.as_display_object().and_then(|dobj| {
+                    stage_object::get_property(dobj, name, activation, is_slash_path)
+                })
+            })
     }
 
     /// Set a named property on the object.
@@ -188,7 +227,8 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
         activation: &mut Activation<'_, 'gc>,
         this: Object<'gc>,
     ) -> Result<(), Error<'gc>> {
-        if let NativeObject::Array(_) = self.native() {
+        let native = self.native();
+        if let NativeObject::Array(_) = native {
             if name == istr!("length") {
                 let new_length = value.coerce_to_i32(activation)?;
                 let old_length = self.get_data(istr!("length"), activation);
@@ -203,6 +243,20 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
                     self.set_length(activation, index.wrapping_add(1))?;
                 }
             }
+        } else if let Some(dobj) = native.as_display_object() {
+            stage_object::notify_property_change(dobj, name, value, activation)?;
+            // 'magic' display object properties (such as _x, _y, etc) take
+            // priority over properties in prototypes.
+            if !self.has_own_property(activation, name) {
+                if let Some(property) = activation
+                    .context
+                    .avm1
+                    .display_properties()
+                    .get_by_name(name)
+                {
+                    return property.set(activation, dobj, value);
+                }
+            }
         }
 
         let setter = match self
@@ -249,6 +303,14 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
         }
     }
 
+    fn as_display_object_no_super(&self) -> Option<DisplayObject<'gc>> {
+        self.0.read().native.as_display_object()
+    }
+
+    fn as_display_object(&self) -> Option<DisplayObject<'gc>> {
+        self.0.read().native.as_display_object()
+    }
+
     /// Call the underlying object.
     ///
     /// This function takes a redundant `this` parameter which should be
@@ -465,17 +527,27 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
 
     /// Checks if the object has a given named property.
     fn has_property(&self, activation: &mut Activation<'_, 'gc>, name: AvmString<'gc>) -> bool {
-        self.has_own_property(activation, name)
-            || if let Value::Object(proto) = self.proto(activation) {
-                proto.has_property(activation, name)
-            } else {
-                false
+        let dobj = self.as_display_object_no_super();
+
+        // Normal property checks
+        if dobj.is_none_or(|o| !o.avm1_removed()) {
+            if self.has_own_property(activation, name) {
+                return true;
+            } else if let Value::Object(proto) = self.proto(activation) {
+                if proto.has_property(activation, name) {
+                    return true;
+                }
             }
+        }
+
+        // Fallback: display object properties
+        dobj.is_some_and(|o| stage_object::has_display_object_property(o, activation, name))
     }
 
     /// Checks if the object has a given named property on itself (and not,
     /// say, the object's prototype or superclass)
     fn has_own_property(&self, activation: &mut Activation<'_, 'gc>, name: AvmString<'gc>) -> bool {
+        // Note that `hasOwnProperty` does NOT return true for display object properties.
         self.0
             .read()
             .properties
@@ -526,14 +598,20 @@ impl<'gc> TObject<'gc> for ScriptObject<'gc> {
         );
 
         // Then our own keys.
-        out_keys.extend(self.0.read().properties.iter().filter_map(move |(k, p)| {
+        let read = self.0.read();
+        out_keys.extend(read.properties.iter().filter_map(move |(k, p)| {
             if include_hidden || p.is_enumerable() {
                 Some(k)
             } else {
                 None
             }
         }));
 
+        // Then display object keys.
+        if let Some(dobj) = read.native.as_display_object() {
+            stage_object::enumerate_keys(dobj, &mut out_keys);
+        }
+
         out_keys
     }