Add EventQueueImpl::target_

This CL is a continuation of
https://chromium-review.googlesource.com/c/chromium/src/+/1088356.

This CL gives an event target to EventQueueImpl and use it instead of
event->target() so that we can have EventQueueImpl and
MediaElementEventQueue with the same structure.

Design Doc: https://docs.google.com/document/d/1BBtBPTarOF4NeVKSWZe3XaDHo4yTGhdlqYm35yVzPs4/edit#

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

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

@@ -34,19 +34,21 @@
 
 namespace blink {
 
-EventQueueImpl* EventQueueImpl::Create(ExecutionContext* context,
+EventQueueImpl* EventQueueImpl::Create(EventTarget* target,
                                        TaskType task_type) {
-  return new EventQueueImpl(context, task_type);
+  return new EventQueueImpl(target, task_type);
 }
 
-EventQueueImpl::EventQueueImpl(ExecutionContext* context, TaskType task_type)
-    : ContextLifecycleObserver(context),
+EventQueueImpl::EventQueueImpl(EventTarget* target, TaskType task_type)
+    : ContextLifecycleObserver(target->GetExecutionContext()),
       task_type_(task_type),
+      target_(target),
       is_closed_(false) {}
 
 EventQueueImpl::~EventQueueImpl() = default;
 
 void EventQueueImpl::Trace(blink::Visitor* visitor) {
+  visitor->Trace(target_);
   visitor->Trace(queued_events_);
   EventQueue::Trace(visitor);
   ContextLifecycleObserver::Trace(visitor);
@@ -99,14 +101,10 @@ void EventQueueImpl::DispatchEvent(Event* event) {
   DCHECK(GetExecutionContext());
 
   probe::AsyncTask async_task(GetExecutionContext(), event);
-  // TODO(hajimehoshi): Don't use |event->target()| here. Assuming the taget
-  // exists here is weird since event target is set later at
-  // |EventTarget::DispatchEvent|.
-  EventTarget* event_target = event->target();
-  if (LocalDOMWindow* window = event_target->ToLocalDOMWindow())
+  if (LocalDOMWindow* window = target_->ToLocalDOMWindow())
     window->DispatchEvent(event, nullptr);
   else
-    event_target->DispatchEvent(event);
+    target_->DispatchEvent(event);
 }
 
 void EventQueueImpl::ContextDestroyed(ExecutionContext* context) {

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

@@ -44,7 +44,7 @@ class CORE_EXPORT EventQueueImpl final : public EventQueue,
  public:
   // TODO(hajimehoshi): TaskType should be determined based on an event instead
   // of specifying here.
-  static EventQueueImpl* Create(ExecutionContext*, TaskType);
+  static EventQueueImpl* Create(EventTarget*, TaskType);
   ~EventQueueImpl() override;
 
   // EventQueue
@@ -53,7 +53,7 @@ class CORE_EXPORT EventQueueImpl final : public EventQueue,
   void CancelAllEvents() override;
 
  private:
-  EventQueueImpl(ExecutionContext*, TaskType);
+  EventQueueImpl(EventTarget*, TaskType);
 
   bool RemoveEvent(Event*);
   void DispatchEvent(Event*);
@@ -63,6 +63,7 @@ class CORE_EXPORT EventQueueImpl final : public EventQueue,
   void DoCancelAllEvents(ExecutionContext*);
 
   const TaskType task_type_;
+  Member<EventTarget> target_;
   HeapLinkedHashSet<Member<Event>> queued_events_;
   bool is_closed_;
 };

third_party/blink/renderer/core/exported/web_plugin_container_impl.cc

@@ -457,7 +457,6 @@ void WebPluginContainerImpl::DispatchProgressEvent(const WebString& type,
 
 void WebPluginContainerImpl::EnqueueMessageEvent(
     const WebDOMMessageEvent& event) {
-  static_cast<Event*>(event)->SetTarget(element_);
   if (!element_->GetExecutionContext())
     return;
   event_queue_->EnqueueEvent(FROM_HERE, event);
@@ -738,8 +737,7 @@ WebPluginContainerImpl::WebPluginContainerImpl(HTMLPlugInElement& element,
     : ContextClient(element.GetDocument().GetFrame()),
       element_(element),
       event_queue_(
-          EventQueueImpl::Create(element.GetDocument().GetExecutionContext(),
-                                 TaskType::kInternalDefault)),
+          EventQueueImpl::Create(&element, TaskType::kInternalDefault)),
       web_plugin_(web_plugin),
       layer_(nullptr),
       touch_event_request_type_(kTouchEventRequestTypeNone),

third_party/blink/renderer/modules/broadcastchannel/broadcast_channel.cc

@@ -101,7 +101,6 @@ void BroadcastChannel::OnMessage(BlinkCloneableMessage message) {
   MessageEvent* event = MessageEvent::Create(
       nullptr, std::move(message.message),
       GetExecutionContext()->GetSecurityOrigin()->ToString());
-  event->SetTarget(this);
   bool success = event_queue_->EnqueueEvent(FROM_HERE, event);
   DCHECK(success);
   ALLOW_UNUSED_LOCAL(success);
@@ -115,8 +114,7 @@ BroadcastChannel::BroadcastChannel(ExecutionContext* execution_context,
                                    const String& name)
     : ContextLifecycleObserver(execution_context),
       origin_(execution_context->GetSecurityOrigin()),
-      event_queue_(
-          EventQueueImpl::Create(execution_context, TaskType::kInternalMedia)),
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalMedia)),
       name_(name),
       binding_(this) {
   mojom::blink::BroadcastChannelProviderPtr& provider =

third_party/blink/renderer/modules/indexeddb/idb_database.cc

@@ -108,8 +108,7 @@ IDBDatabase::IDBDatabase(ExecutionContext* context,
                          v8::Isolate* isolate)
     : ContextLifecycleObserver(context),
       backend_(std::move(backend)),
-      event_queue_(
-          EventQueueImpl::Create(context, TaskType::kInternalIndexedDB)),
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalIndexedDB)),
       database_callbacks_(callbacks),
       isolate_(isolate) {
   database_callbacks_->Connect(this);
@@ -500,7 +499,6 @@ void IDBDatabase::OnVersionChange(int64_t old_version, int64_t new_version) {
 
 void IDBDatabase::EnqueueEvent(Event* event) {
   DCHECK(GetExecutionContext());
-  event->SetTarget(this);
   event_queue_->EnqueueEvent(FROM_HERE, event);
 }
 

third_party/blink/renderer/modules/indexeddb/idb_request.cc

@@ -138,8 +138,8 @@ IDBRequest::IDBRequest(ScriptState* script_state,
       isolate_(script_state->GetIsolate()),
       metrics_(std::move(metrics)),
       source_(source),
-      event_queue_(EventQueueImpl::Create(ExecutionContext::From(script_state),
-                                          TaskType::kInternalIndexedDB)) {}
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalIndexedDB)) {
+}
 
 IDBRequest::~IDBRequest() {
   DCHECK((ready_state_ == DONE && metrics_.IsEmpty()) ||
@@ -638,7 +638,8 @@ DispatchEventResult IDBRequest::DispatchEventInternal(Event* event) {
     return DispatchEventResult::kCanceledBeforeDispatch;
   DCHECK_EQ(ready_state_, PENDING);
   DCHECK(has_pending_activity_);
-  DCHECK_EQ(event->target(), this);
+  event->SetTarget(this);
+  event->SetCurrentTarget(this);
 
   if (event->type() != EventTypeNames::blocked)
     ready_state_ = DONE;
@@ -760,8 +761,6 @@ void IDBRequest::EnqueueEvent(Event* event) {
       << "When queueing event " << event->type() << ", ready_state_ was "
       << ready_state_;
 
-  event->SetTarget(this);
-
   event_queue_->EnqueueEvent(FROM_HERE, event);
 }
 

third_party/blink/renderer/modules/indexeddb/idb_transaction.cc

@@ -90,8 +90,7 @@ IDBTransaction::IDBTransaction(ExecutionContext* execution_context,
       mode_(kWebIDBTransactionModeReadOnly),
       scope_(scope),
       state_(kActive),
-      event_queue_(EventQueueImpl::Create(execution_context,
-                                          TaskType::kInternalIndexedDB)) {
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalIndexedDB)) {
   DCHECK(database_);
   DCHECK(!scope_.IsEmpty()) << "Observer transactions must operate "
                                "on a well-defined set of stores";
@@ -108,8 +107,7 @@ IDBTransaction::IDBTransaction(ScriptState* script_state,
       database_(db),
       mode_(mode),
       scope_(scope),
-      event_queue_(EventQueueImpl::Create(ExecutionContext::From(script_state),
-                                          TaskType::kInternalIndexedDB)) {
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalIndexedDB)) {
   DCHECK(database_);
   DCHECK(!scope_.IsEmpty()) << "Non-versionchange transactions must operate "
                                "on a well-defined set of stores";
@@ -137,8 +135,7 @@ IDBTransaction::IDBTransaction(ExecutionContext* execution_context,
       mode_(kWebIDBTransactionModeVersionChange),
       state_(kInactive),
       old_database_metadata_(old_metadata),
-      event_queue_(EventQueueImpl::Create(execution_context,
-                                          TaskType::kInternalIndexedDB)) {
+      event_queue_(EventQueueImpl::Create(this, TaskType::kInternalIndexedDB)) {
   DCHECK(database_);
   DCHECK(open_db_request_);
   DCHECK(scope_.IsEmpty());
@@ -526,7 +523,8 @@ DispatchEventResult IDBTransaction::DispatchEventInternal(Event* event) {
   DCHECK_NE(state_, kFinished);
   DCHECK(has_pending_activity_);
   DCHECK(GetExecutionContext());
-  DCHECK_EQ(event->target(), this);
+  event->SetTarget(this);
+  event->SetCurrentTarget(this);
   state_ = kFinished;
 
   HeapVector<Member<EventTarget>> targets;
@@ -556,7 +554,6 @@ void IDBTransaction::EnqueueEvent(Event* event) {
   if (!GetExecutionContext())
     return;
 
-  event->SetTarget(this);
   event_queue_->EnqueueEvent(FROM_HERE, event);
 }
 

third_party/blink/renderer/modules/indexeddb/idb_transaction_test.cc

@@ -186,6 +186,8 @@ TEST_F(IDBTransactionTest, ContextDestroyedAfterDone) {
   // event, so that the transaction can go away.
   EXPECT_EQ(1U, live_transactions.size());
 
+  // Dispatch all the enqueued events.
+  base::RunLoop().RunUntilIdle();
   ThreadState::Current()->CollectAllGarbage();
   EXPECT_EQ(0U, live_transactions.size());
 }