Remove EventSender from ImageLoader

third_party/WebKit/Source/core/loader/ImageLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 12 matching lines @@
 #include "core/loader/ImageLoader.h"
 
 #include <memory>
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/IncrementLoadEventDelayCount.h"
 #include "core/events/Event.h"
-#include "core/events/EventSender.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutVideo.h"
 #include "core/layout/svg/LayoutSVGImage.h"
 #include "core/probe/CoreProbes.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/bindings/Microtask.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/loader/fetch/FetchParameters.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceLoadingLog.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
-static ImageEventSender& LoadEventSender() {
-  DEFINE_STATIC_LOCAL(ImageEventSender, sender,
-                      (ImageEventSender::Create(EventTypeNames::load)));
-  return sender;
-}
-
-static ImageEventSender& ErrorEventSender() {
-  DEFINE_STATIC_LOCAL(ImageEventSender, sender,
-                      (ImageEventSender::Create(EventTypeNames::error)));
-  return sender;
-}
-
 static inline bool PageIsBeingDismissed(Document* document) {
   return document->PageDismissalEventBeingDispatched() !=
          Document::kNoDismissal;
 }
 
 static ImageLoader::BypassMainWorldBehavior ShouldBypassMainWorldCSP(
     ImageLoader* loader) {
   DCHECK(loader);
   DCHECK(loader->GetElement());
   if (loader->GetElement()->GetDocument().GetFrame() &&
@@ skipping 69 matching lines @@
   UpdateFromElementBehavior update_behavior_;
   RefPtr<ScriptState> script_state_;
   WeakPtrFactory<Task> weak_factory_;
   ReferrerPolicy referrer_policy_;
   KURL request_url_;
 };
 
 ImageLoader::ImageLoader(Element* element)
     : element_(element),
       deref_element_timer_(this, &ImageLoader::TimerFired),
-      has_pending_load_event_(false),
-      has_pending_error_event_(false),
       image_complete_(true),
       loading_image_document_(false),
       element_is_protected_(false),
       suppress_error_events_(false) {
   RESOURCE_LOADING_DVLOG(1) << "new ImageLoader " << this;
 }
 
 ImageLoader::~ImageLoader() {}
 
 void ImageLoader::Dispose() {
   RESOURCE_LOADING_DVLOG(1)
       << "~ImageLoader " << this
-      << "; m_hasPendingLoadEvent=" << has_pending_load_event_
-      << ", m_hasPendingErrorEvent=" << has_pending_error_event_;
+      << "; pending load event=" << pending_load_event_.IsActive()
+      << ", pending error event=" << pending_error_event_.IsActive();
 
   if (image_) {
     image_->RemoveObserver(this);
     image_ = nullptr;
     delay_until_image_notify_finished_ = nullptr;
   }
 }
 
 DEFINE_TRACE(ImageLoader) {
   visitor->Trace(image_);
@@ skipping 10 matching lines @@
   UpdatedHasPendingEvent();
 }
 
 void ImageLoader::SetImageWithoutConsideringPendingLoadEvent(
     ImageResourceContent* new_image) {
   DCHECK(failed_load_url_.IsEmpty());
   ImageResourceContent* old_image = image_.Get();
   if (new_image != old_image) {
     image_ = new_image;
     delay_until_image_notify_finished_ = nullptr;
-    if (has_pending_load_event_) {
-      LoadEventSender().CancelEvent(this);
-      has_pending_load_event_ = false;
-    }
-    if (has_pending_error_event_) {
-      ErrorEventSender().CancelEvent(this);
-      has_pending_error_event_ = false;
-    }
+    if (pending_load_event_.IsActive())
+      pending_load_event_.Cancel();
+    if (pending_error_event_.IsActive())
+      pending_error_event_.Cancel();
     image_complete_ = true;
     if (new_image) {
       new_image->AddObserver(this);
     }
     if (old_image) {
       old_image->RemoveObserver(this);
     }
   }
 
   if (LayoutImageResource* image_resource = GetLayoutImageResource())
@@ skipping 14 matching lines @@
     params.SetCrossOriginAccessControl(
         element.GetDocument().GetSecurityOrigin(), cross_origin);
   }
 
   if (client_hints_preferences.ShouldSendResourceWidth() &&
       isHTMLImageElement(element))
     params.SetResourceWidth(toHTMLImageElement(element).GetResourceWidth());
 }
 
 inline void ImageLoader::DispatchErrorEvent() {
-  has_pending_error_event_ = true;
-  ErrorEventSender().DispatchEventSoon(this);
+  pending_error_event_ =
+      TaskRunnerHelper::Get(TaskType::kDOMManipulation,
+                            &GetElement()->GetDocument())
+          ->PostCancellableTask(
+              BLINK_FROM_HERE,
+              WTF::Bind(&ImageLoader::DispatchPendingErrorEvent,
+                        WrapPersistent(this),
+                        WTF::Passed(IncrementLoadEventDelayCount::Create(
+                            GetElement()->GetDocument()))));
 }
 
 inline void ImageLoader::CrossSiteOrCSPViolationOccurred(
     AtomicString image_source_url) {
   failed_load_url_ = image_source_url;
 }
 
 inline void ImageLoader::ClearFailedLoadURL() {
   failed_load_url_ = AtomicString();
 }
@@ skipping 75 matching lines @@
       DispatchErrorEvent();
     }
     NoImageResourceToLoad();
   }
 
   ImageResourceContent* old_image = image_.Get();
   if (update_behavior == kUpdateSizeChanged && element_->GetLayoutObject() &&
       element_->GetLayoutObject()->IsImage() && new_image == old_image) {
     ToLayoutImage(element_->GetLayoutObject())->IntrinsicSizeChanged();
   } else {
-    if (has_pending_load_event_) {
-      LoadEventSender().CancelEvent(this);
-      has_pending_load_event_ = false;
-    }
+    if (pending_load_event_.IsActive())
+      pending_load_event_.Cancel();
 
     // Cancel error events that belong to the previous load, which is now
     // cancelled by changing the src attribute. If newImage is null and
     // m_hasPendingErrorEvent is true, we know the error event has been just
     // posted by this load and we should not cancel the event.
     // FIXME: If both previous load and this one got blocked with an error, we
     // can receive one error event instead of two.
-    if (has_pending_error_event_ && new_image) {
-      ErrorEventSender().CancelEvent(this);
-      has_pending_error_event_ = false;
-    }
+    if (pending_error_event_.IsActive() && new_image)
+      pending_error_event_.Cancel();
 
     image_ = new_image;
     image_complete_ = !new_image;
     delay_until_image_notify_finished_ = nullptr;
 
     UpdateLayoutObject();
     // If newImage exists and is cached, addObserver() will result in the load
     // event being queued to fire. Ensure this happens after beforeload is
     // dispatched.
     if (new_image) {
@@ skipping 113 matching lines @@
   if (!document.IsActive())
     return;
 
   delay_until_image_notify_finished_ =
       IncrementLoadEventDelayCount::Create(document);
 }
 
 void ImageLoader::ImageNotifyFinished(ImageResourceContent* resource) {
   RESOURCE_LOADING_DVLOG(1)
       << "ImageLoader::imageNotifyFinished " << this
-      << "; m_hasPendingLoadEvent=" << has_pending_load_event_;
+      << "; m_hasPendingLoadEvent=" << pending_load_event_.IsActive();
 
   DCHECK(failed_load_url_.IsEmpty());
   DCHECK_EQ(resource, image_.Get());
 
   if (loading_image_document_) {
     CHECK(image_complete_);
   } else {
     CHECK(!image_complete_);
   }
 
   image_complete_ = true;
   delay_until_image_notify_finished_ = nullptr;
 
   // Update ImageAnimationPolicy for m_image.
   if (image_)
     image_->UpdateImageAnimationPolicy();
 
   UpdateLayoutObject();
 
   if (image_ && image_->GetImage() && image_->GetImage()->IsSVGImage())
     ToSVGImage(image_->GetImage())
         ->UpdateUseCounters(GetElement()->GetDocument());
 
-  if (loading_image_document_)
+  if (loading_image_document_) {
+    CHECK(!pending_load_event_.IsActive());
     return;
+  }
 
   if (resource->ErrorOccurred()) {
-    LoadEventSender().CancelEvent(this);
-    has_pending_load_event_ = false;
+    pending_load_event_.Cancel();
 
     if (resource->GetResourceError().IsAccessCheck()) {
       CrossSiteOrCSPViolationOccurred(
           AtomicString(resource->GetResourceError().FailingURL()));
     }
 
     // The error event should not fire if the image data update is a result of
     // environment change.
     // https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element:the-img-element-55
     if (!suppress_error_events_)
       DispatchErrorEvent();
 
     // Only consider updating the protection ref-count of the Element
     // immediately before returning from this function as doing so might result
     // in the destruction of this ImageLoader.
     UpdatedHasPendingEvent();
     return;
   }
-  has_pending_load_event_ = true;
-  LoadEventSender().DispatchEventSoon(this);
+
+  CHECK(!pending_load_event_.IsActive());
+  pending_load_event_ =
+      TaskRunnerHelper::Get(TaskType::kDOMManipulation,
+                            &GetElement()->GetDocument())
+          ->PostCancellableTask(
+              BLINK_FROM_HERE,
+              WTF::Bind(&ImageLoader::DispatchPendingLoadEvent,
+                        WrapPersistent(this),
+                        WTF::Passed(IncrementLoadEventDelayCount::Create(
+                            GetElement()->GetDocument()))));
 }
 
 LayoutImageResource* ImageLoader::GetLayoutImageResource() {
   LayoutObject* layout_object = element_->GetLayoutObject();
 
   if (!layout_object)
     return 0;
 
   // We don't return style generated image because it doesn't belong to the
   // ImageLoader. See <https://bugs.webkit.org/show_bug.cgi?id=42840>
@@ skipping 26 matching lines @@
 
 void ImageLoader::UpdatedHasPendingEvent() {
   // If an Element that does image loading is removed from the DOM the
   // load/error event for the image is still observable. As long as the
   // ImageLoader is actively loading, the Element itself needs to be ref'ed to
   // keep it from being destroyed by DOM manipulation or garbage collection. If
   // such an Element wishes for the load to stop when removed from the DOM it
   // needs to stop the ImageLoader explicitly.
   bool was_protected = element_is_protected_;
   element_is_protected_ = (image_ && !image_complete_) ||
-                          has_pending_load_event_ || has_pending_error_event_;
+                          pending_load_event_.IsActive() ||
+                          pending_error_event_.IsActive();
   if (was_protected == element_is_protected_)
     return;
 
   if (element_is_protected_) {
     if (deref_element_timer_.IsActive())
       deref_element_timer_.Stop();
     else
       keep_alive_ = element_;
   } else {
     DCHECK(!deref_element_timer_.IsActive());
     deref_element_timer_.StartOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 void ImageLoader::TimerFired(TimerBase*) {
   keep_alive_.Clear();
 }
 
-void ImageLoader::DispatchPendingEvent(ImageEventSender* event_sender) {
-  RESOURCE_LOADING_DVLOG(1) << "ImageLoader::dispatchPendingEvent " << this;
-  DCHECK(event_sender == &LoadEventSender() ||
-         event_sender == &ErrorEventSender());
-  const AtomicString& event_type = event_sender->EventType();
-  if (event_type == EventTypeNames::load)
-    DispatchPendingLoadEvent();
-  if (event_type == EventTypeNames::error)
-    DispatchPendingErrorEvent();
-}
-
-void ImageLoader::DispatchPendingLoadEvent() {
-  CHECK(has_pending_load_event_);
+void ImageLoader::DispatchPendingLoadEvent(
+    std::unique_ptr<IncrementLoadEventDelayCount> count) {
   if (!image_)
     return;
   CHECK(image_complete_);
-  has_pending_load_event_ = false;
-  CHECK(image_complete_);
   if (GetElement()->GetDocument().GetFrame())
     DispatchLoadEvent();
 
   // Only consider updating the protection ref-count of the Element immediately
   // before returning from this function as doing so might result in the
   // destruction of this ImageLoader.
   UpdatedHasPendingEvent();
+
+  // Checks Document's load event synchronously here for performance.
+  // This is safe because dispatchPendingLoadEvent() is called asynchronously.
+  count->ClearAndCheckLoadEvent();
 }
 
-void ImageLoader::DispatchPendingErrorEvent() {
-  if (!has_pending_error_event_)
-    return;
-  has_pending_error_event_ = false;
-
+void ImageLoader::DispatchPendingErrorEvent(
+    std::unique_ptr<IncrementLoadEventDelayCount> count) {
   if (GetElement()->GetDocument().GetFrame())
     GetElement()->DispatchEvent(Event::Create(EventTypeNames::error));
 
   // Only consider updating the protection ref-count of the Element immediately
   // before returning from this function as doing so might result in the
   // destruction of this ImageLoader.
   UpdatedHasPendingEvent();
+
+  // Checks Document's load event synchronously here for performance.
+  // This is safe because dispatchPendingErrorEvent() is called asynchronously.
+  count->ClearAndCheckLoadEvent();
 }
 
 bool ImageLoader::GetImageAnimationPolicy(ImageAnimationPolicy& policy) {
   if (!GetElement()->GetDocument().GetSettings())
     return false;
 
   policy = GetElement()->GetDocument().GetSettings()->GetImageAnimationPolicy();
   return true;
 }
 
-void ImageLoader::DispatchPendingLoadEvents() {
-  LoadEventSender().DispatchPendingEvents();
-}
-
-void ImageLoader::DispatchPendingErrorEvents() {
-  ErrorEventSender().DispatchPendingEvents();
-}
-
 void ImageLoader::ElementDidMoveToNewDocument() {
   if (delay_until_do_update_from_element_) {
     delay_until_do_update_from_element_->DocumentChanged(
         element_->GetDocument());
   }
   if (delay_until_image_notify_finished_) {
     delay_until_image_notify_finished_->DocumentChanged(
         element_->GetDocument());
   }
   ClearFailedLoadURL();
   SetImage(0);
 }
 
 }  // namespace blink