Use event->target() instead of MediaElementEventQueue::owner_

We realized that MediaElementEventQueue : target is not 1 : 1. Then,
Having MediaElementEventQueue own a target doesn't make sense. This CL
enforces to set a target of an event before enqueuing and use it when
dispatching.

Bug: 846618
Change-Id: Iacc19e6c55040fe05e4883fa33f570b3424650e0
Reviewed-on: https://chromium-review.googlesource.com/1105803Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#568403}

third_party/blink/renderer/core/dom/events/media_element_event_queue.cc

@@ -32,14 +32,13 @@
 
 namespace blink {
 
-MediaElementEventQueue* MediaElementEventQueue::Create(EventTarget* owner) {
-  return new MediaElementEventQueue(owner);
+MediaElementEventQueue* MediaElementEventQueue::Create(
+    ExecutionContext* context) {
+  return new MediaElementEventQueue(context);
 }
 
-MediaElementEventQueue::MediaElementEventQueue(EventTarget* owner)
-    : ContextLifecycleObserver(owner->GetExecutionContext()),
-      owner_(owner),
-      is_closed_(false) {
+MediaElementEventQueue::MediaElementEventQueue(ExecutionContext* context)
+    : ContextLifecycleObserver(context), is_closed_(false) {
   if (!GetExecutionContext())
     Close(nullptr);
 }
@@ -47,7 +46,6 @@ MediaElementEventQueue::MediaElementEventQueue(EventTarget* owner)
 MediaElementEventQueue::~MediaElementEventQueue() = default;
 
 void MediaElementEventQueue::Trace(blink::Visitor* visitor) {
-  visitor->Trace(owner_);
   visitor->Trace(pending_events_);
   ContextLifecycleObserver::Trace(visitor);
 }
@@ -57,6 +55,7 @@ bool MediaElementEventQueue::EnqueueEvent(const base::Location& from_here,
   if (is_closed_)
     return false;
 
+  DCHECK(event->target());
   DCHECK(GetExecutionContext());
 
   TRACE_EVENT_ASYNC_BEGIN1("event", "MediaElementEventQueue:enqueueEvent",
@@ -90,8 +89,7 @@ void MediaElementEventQueue::DispatchEvent(Event* event) {
   probe::AsyncTask async_task(GetExecutionContext(), event);
   TRACE_EVENT_ASYNC_STEP_INTO1("event", "MediaElementEventQueue:enqueueEvent",
                                event, "dispatch", "type", type);
-  EventTarget* target = event->target() ? event->target() : owner_.Get();
-  target->DispatchEvent(event);
+  event->target()->DispatchEvent(event);
   TRACE_EVENT_ASYNC_END1("event", "MediaElementEventQueue:enqueueEvent", event,
                          "type", type);
 }
@@ -115,7 +113,6 @@ void MediaElementEventQueue::ContextDestroyed(ExecutionContext* context) {
 void MediaElementEventQueue::Close(ExecutionContext* context) {
   is_closed_ = true;
   DoCancelAllEvents(context);
-  owner_.Clear();
 }
 
 void MediaElementEventQueue::DoCancelAllEvents(ExecutionContext* context) {

third_party/blink/renderer/core/dom/events/media_element_event_queue.h

@@ -44,7 +44,7 @@ class CORE_EXPORT MediaElementEventQueue final
   USING_GARBAGE_COLLECTED_MIXIN(MediaElementEventQueue);
 
  public:
-  static MediaElementEventQueue* Create(EventTarget*);
+  static MediaElementEventQueue* Create(ExecutionContext*);
   ~MediaElementEventQueue();
 
   void Trace(blink::Visitor*) override;
@@ -54,7 +54,7 @@ class CORE_EXPORT MediaElementEventQueue final
   bool HasPendingEvents() const;
 
  private:
-  explicit MediaElementEventQueue(EventTarget*);
+  explicit MediaElementEventQueue(ExecutionContext*);
   bool RemoveEvent(Event* event);
   void DispatchEvent(Event* event);
 
@@ -62,7 +62,6 @@ class CORE_EXPORT MediaElementEventQueue final
   void Close(ExecutionContext*);
   void DoCancelAllEvents(ExecutionContext*);
 
-  Member<EventTarget> owner_;
   HeapHashSet<Member<Event>> pending_events_;
 
   bool is_closed_;

third_party/blink/renderer/core/html/media/html_media_element.cc

@@ -464,7 +464,7 @@ HTMLMediaElement::HTMLMediaElement(const QualifiedName& tag_name,
           this,
           &HTMLMediaElement::CheckViewportIntersectionTimerFired),
       played_time_ranges_(),
-      async_event_queue_(MediaElementEventQueue::Create(this)),
+      async_event_queue_(MediaElementEventQueue::Create(GetExecutionContext())),
       playback_rate_(1.0f),
       default_playback_rate_(1.0f),
       network_state_(kNetworkEmpty),
@@ -751,7 +751,9 @@ void HTMLMediaElement::ScheduleNextSourceChild() {
 }
 
 void HTMLMediaElement::ScheduleEvent(const AtomicString& event_name) {
-  ScheduleEvent(Event::CreateCancelable(event_name));
+  Event* event = Event::CreateCancelable(event_name);
+  event->SetTarget(this);
+  ScheduleEvent(event);
 }
 
 void HTMLMediaElement::ScheduleEvent(Event* event) {

third_party/blink/renderer/core/html/track/text_track_list.cc

@@ -36,7 +36,9 @@
 namespace blink {
 
 TextTrackList::TextTrackList(HTMLMediaElement* owner)
-    : owner_(owner), async_event_queue_(MediaElementEventQueue::Create(this)) {}
+    : owner_(owner),
+      async_event_queue_(
+          MediaElementEventQueue::Create(GetExecutionContext())) {}
 
 TextTrackList::~TextTrackList() = default;
 
@@ -247,8 +249,9 @@ ExecutionContext* TextTrackList::GetExecutionContext() const {
 
 void TextTrackList::ScheduleTrackEvent(const AtomicString& event_name,
                                        TextTrack* track) {
-  async_event_queue_->EnqueueEvent(FROM_HERE,
-                                   TrackEvent::Create(event_name, track));
+  Event* event = TrackEvent::Create(event_name, track);
+  event->SetTarget(this);
+  async_event_queue_->EnqueueEvent(FROM_HERE, event);
 }
 
 void TextTrackList::ScheduleAddTrackEvent(TextTrack* track) {
@@ -270,8 +273,9 @@ void TextTrackList::ScheduleChangeEvent() {
   // Fire a simple event named change at the media element's textTracks
   // attribute's TextTrackList object.
 
-  async_event_queue_->EnqueueEvent(FROM_HERE,
-                                   Event::Create(EventTypeNames::change));
+  Event* event = Event::Create(EventTypeNames::change);
+  event->SetTarget(this);
+  async_event_queue_->EnqueueEvent(FROM_HERE, event);
 }
 
 void TextTrackList::ScheduleRemoveTrackEvent(TextTrack* track) {

third_party/blink/renderer/modules/encryptedmedia/media_key_session.cc

@@ -329,7 +329,7 @@ MediaKeySession::MediaKeySession(ScriptState* script_state,
                                  MediaKeys* media_keys,
                                  WebEncryptedMediaSessionType session_type)
     : ContextLifecycleObserver(ExecutionContext::From(script_state)),
-      async_event_queue_(MediaElementEventQueue::Create(this)),
+      async_event_queue_(MediaElementEventQueue::Create(GetExecutionContext())),
       media_keys_(media_keys),
       session_type_(session_type),
       expiration_(std::numeric_limits<double>::quiet_NaN()),

third_party/blink/renderer/modules/mediasource/media_source.cc

@@ -113,7 +113,7 @@ MediaSource* MediaSource::Create(ExecutionContext* context) {
 MediaSource::MediaSource(ExecutionContext* context)
     : ContextLifecycleObserver(context),
       ready_state_(ClosedKeyword()),
-      async_event_queue_(MediaElementEventQueue::Create(this)),
+      async_event_queue_(MediaElementEventQueue::Create(context)),
       attached_element_(nullptr),
       source_buffers_(SourceBufferList::Create(GetExecutionContext(),
                                                async_event_queue_.Get())),