avm2: Use return value of Event.target getter to determine whether to clone when dispatching event

Author: Lord-McSweeney

core/src/avm2/events.rs

@@ -1,7 +1,6 @@
 //! Core event structure
 
 use crate::avm2::activation::Activation;
-use crate::avm2::error::make_error_2007;
 use crate::avm2::globals::slots::flash_events_event_dispatcher as slots;
 use crate::avm2::object::{EventObject, Object, TObject};
 use crate::avm2::value::Value;
@@ -73,9 +72,6 @@ pub struct Event<'gc> {
 
     /// The name of the event being triggered.
     event_type: AvmString<'gc>,
-
-    /// Whether is event has been dispatched before.
-    dispatched: bool,
 }
 
 impl<'gc> Event<'gc> {
@@ -93,7 +89,6 @@ impl<'gc> Event<'gc> {
             event_phase: EventPhase::AtTarget,
             target: None,
             event_type: event_type.into(),
-            dispatched: false,
         }
     }
 
@@ -373,13 +368,14 @@ pub fn parent_of(target: Object<'_>) -> Option<Object<'_>> {
 fn dispatch_event_to_target<'gc>(
     activation: &mut Activation<'_, 'gc>,
     dispatcher: Object<'gc>,
-    target: Object<'gc>,
+    real_target: Object<'gc>,
+    current_target: Object<'gc>,
     event: EventObject<'gc>,
     simulate_dispatch: bool,
 ) -> Result<(), Error<'gc>> {
     avm_debug!(
         activation.context.avm2,
-        "Event dispatch: {} to {target:?}",
+        "Event dispatch: {} to {current_target:?}",
         event.event().event_type(),
     );
 
@@ -402,10 +398,9 @@ fn dispatch_event_to_target<'gc>(
         .iter_event_handlers(name, use_capture)
         .collect();
 
-    evtmut.set_current_target(target);
-
     if !handlers.is_empty() {
-        evtmut.dispatched = true;
+        evtmut.set_target(real_target);
+        evtmut.set_current_target(current_target);
     }
 
     drop(evtmut);
@@ -437,7 +432,7 @@ fn dispatch_event_to_target<'gc>(
 pub fn dispatch_event<'gc>(
     activation: &mut Activation<'_, 'gc>,
     this: Object<'gc>,
-    event_object: EventObject<'gc>,
+    event: EventObject<'gc>,
     simulate_dispatch: bool,
 ) -> Result<bool, Error<'gc>> {
     let target = this.get_slot(slots::TARGET).as_object().unwrap_or(this);
@@ -455,23 +450,9 @@ pub fn dispatch_event<'gc>(
         parent = parent_dobj.parent();
     }
 
-    let dispatched = event_object.event().dispatched;
-
-    let event = if dispatched {
-        Value::from(event_object)
-            .call_public_property("clone", &[], activation)?
-            .as_object()
-            .ok_or_else(|| make_error_2007(activation, "event"))?
-            .as_event_object()
-            .expect("Event.clone should return an Event")
-    } else {
-        event_object
-    };
-
     let mut evtmut = event.event_mut(activation.gc());
 
     evtmut.set_phase(EventPhase::Capturing);
-    evtmut.set_target(target);
 
     drop(evtmut);
 
@@ -480,15 +461,22 @@ pub fn dispatch_event<'gc>(
             break;
         }
 
-        dispatch_event_to_target(activation, *ancestor, *ancestor, event, simulate_dispatch)?;
+        dispatch_event_to_target(
+            activation,
+            *ancestor,
+            target,
+            *ancestor,
+            event,
+            simulate_dispatch,
+        )?;
     }
 
     event
         .event_mut(activation.gc())
         .set_phase(EventPhase::AtTarget);
 
     if !event.event().is_propagation_stopped() {
-        dispatch_event_to_target(activation, this, target, event, simulate_dispatch)?;
+        dispatch_event_to_target(activation, this, target, target, event, simulate_dispatch)?;
     }
 
     event
@@ -501,10 +489,17 @@ pub fn dispatch_event<'gc>(
                 break;
             }
 
-            dispatch_event_to_target(activation, *ancestor, *ancestor, event, simulate_dispatch)?;
+            dispatch_event_to_target(
+                activation,
+                *ancestor,
+                target,
+                *ancestor,
+                event,
+                simulate_dispatch,
+            )?;
         }
     }
 
-    let handled = event.event().dispatched;
+    let handled = event.event().target.is_some();
     Ok(handled)
 }

core/src/avm2/globals/flash/events/EventDispatcher.as

@@ -12,8 +12,19 @@ package flash.events {
 
         public native function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void;
         public native function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void;
-        public native function dispatchEvent(event:Event):Boolean;
         public native function hasEventListener(type:String):Boolean;
+
+        public function dispatchEvent(event:Event):Boolean {
+            // Some SWFs rely on the getter for `target` being called
+            if (event.target) {
+                return this.dispatchEventInternal(event.clone());
+            } else {
+                return this.dispatchEventInternal(event);
+            }
+        }
+
+        private native function dispatchEventInternal(event:Event):Boolean;
+
         public native function willTrigger(type:String):Boolean;
 
         public function toString():String {

core/src/avm2/globals/flash/events/event_dispatcher.rs

@@ -1,7 +1,7 @@
 //! `flash.events.EventDispatcher` builtin/prototype
 
 use crate::avm2::activation::Activation;
-use crate::avm2::events::{dispatch_event as dispatch_event_internal, parent_of};
+use crate::avm2::events;
 use crate::avm2::globals::slots::flash_events_event_dispatcher as slots;
 use crate::avm2::object::{DispatchObject, Object, TObject};
 use crate::avm2::parameters::ParametersExt;
@@ -111,15 +111,15 @@ pub fn will_trigger<'gc>(
 
     let target = this.get_slot(slots::TARGET).as_object().unwrap_or(this);
 
-    if let Some(parent) = parent_of(target) {
+    if let Some(parent) = events::parent_of(target) {
         return will_trigger(activation, Value::Object(parent), args);
     }
 
     Ok(false.into())
 }
 
 /// Implements `EventDispatcher.dispatchEvent`.
-pub fn dispatch_event<'gc>(
+pub fn dispatch_event_internal<'gc>(
     activation: &mut Activation<'_, 'gc>,
     this: Value<'gc>,
     args: &[Value<'gc>],
@@ -131,7 +131,7 @@ pub fn dispatch_event<'gc>(
     // AS3-side typing guarantees that the event is actually an Event
     let event = event.as_event_object().unwrap();
 
-    dispatch_event_internal(activation, this, event, false)?;
+    events::dispatch_event(activation, this, event, false)?;
 
     let not_canceled = !event.event().is_cancelled();
     Ok(not_canceled.into())

tests/tests/swfs/avm2/event_target_set/output.txt

@@ -0,0 +1,9 @@
+target before dispatch 1: null
+currentTarget before dispatch 1: null
+target after dispatch 1: null
+currentTarget after dispatch 1: null
+target before dispatch 2: null
+currentTarget before dispatch 2: null
+Dispatched!
+target after dispatch 2: [object EventDispatcher]
+currentTarget after dispatch 2: [object EventDispatcher]

tests/tests/swfs/avm2/event_target_set/test.swf

@@ -0,0 +1 @@
+num_frames = 1