Remove the lifetime hack in ImageLoader where it keeps its assoc element alive

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 138 matching lines @@
   BypassMainWorldBehavior should_bypass_main_world_csp_;
   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
       << "; has_pending_load_event_=" << has_pending_load_event_
       << ", has_pending_error_event_=" << has_pending_error_event_;
 
   if (image_) {
     image_->RemoveObserver(this);
     image_ = nullptr;
     delay_until_image_notify_finished_ = nullptr;
   }
 }
 
 DEFINE_TRACE(ImageLoader) {
   visitor->Trace(image_);
   visitor->Trace(image_resource_for_image_document_);
   visitor->Trace(element_);
 }
 
 void ImageLoader::SetImageForTest(ImageResourceContent* new_image) {
   DCHECK(new_image);
   SetImageWithoutConsideringPendingLoadEvent(new_image);
-
-  // 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();
 }
 
 void ImageLoader::ClearImage() {
   SetImageWithoutConsideringPendingLoadEvent(nullptr);
-
-  // 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();
 }
 
 void ImageLoader::SetImageForImageDocument(ImageResource* new_image_resource) {
   DCHECK(loading_image_document_);
   DCHECK(new_image_resource);
   DCHECK(new_image_resource->GetContent());
 
   image_resource_for_image_document_ = new_image_resource;
   SetImageWithoutConsideringPendingLoadEvent(new_image_resource->GetContent());
 
   // |image_complete_| is always true for ImageDocument loading, while the
   // loading is just started.
   // TODO(hiroshige): clean up the behavior of flags. https://crbug.com/719759
   image_complete_ = true;
-
-  // 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();
 }
 
 void ImageLoader::SetImageWithoutConsideringPendingLoadEvent(
     ImageResourceContent* new_image) {
   DCHECK(failed_load_url_.IsEmpty());
   ImageResourceContent* old_image = image_.Get();
   if (new_image != old_image) {
     if (has_pending_load_event_) {
       LoadEventSender().CancelEvent(this);
       has_pending_load_event_ = false;
@@ skipping 171 matching lines @@
     if (new_image) {
       new_image->AddObserver(this);
     }
     if (old_image) {
       old_image->RemoveObserver(this);
     }
   }
 
   if (LayoutImageResource* image_resource = GetLayoutImageResource())
     image_resource->ResetAnimation();
-
-  // 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();
 }
 
 void ImageLoader::UpdateFromElement(UpdateFromElementBehavior update_behavior,
                                     ReferrerPolicy referrer_policy) {
   AtomicString image_source_url = element_->ImageSourceURL();
   suppress_error_events_ = (update_behavior == kUpdateSizeChanged);
 
   if (update_behavior == kUpdateIgnorePreviousError)
     ClearFailedLoadURL();
 
@@ skipping 150 matching lines @@
     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);
 }
 
 LayoutImageResource* ImageLoader::GetLayoutImageResource() {
   LayoutObject* layout_object = element_->GetLayoutObject();
 
   if (!layout_object)
@@ skipping 32 matching lines @@
   // Regular image loading is in progress.
   if (image_ && !image_complete_ && !loading_image_document_)
     return true;
 
   if (has_pending_load_event_ || has_pending_error_event_)
     return true;
 
   return false;
 }
 
-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_ = HasPendingEvent();
-  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_);
   if (!image_)
     return;
   CHECK(image_complete_);
   has_pending_load_event_ = false;
   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();
 }
 
 void ImageLoader::DispatchPendingErrorEvent() {
   CHECK(has_pending_error_event_);
   has_pending_error_event_ = false;
 
   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();
 }
 
 bool ImageLoader::GetImageAnimationPolicy(ImageAnimationPolicy& policy) {
   if (!GetElement()->GetDocument().GetSettings())
     return false;
 
   policy = GetElement()->GetDocument().GetSettings()->GetImageAnimationPolicy();
   return true;
 }
 
@@ skipping 12 matching lines @@
   }
   if (delay_until_image_notify_finished_) {
     delay_until_image_notify_finished_->DocumentChanged(
         element_->GetDocument());
   }
   ClearFailedLoadURL();
   ClearImage();
 }
 
 }  // namespace blink