Call imageNotifyFinished() just before ResourceClient::notifyFinished()

third_party/WebKit/Source/core/fetch/ImageResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 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
@@ skipping 83 matching lines @@
 }
 
 DEFINE_TRACE(ImageResource)
 {
     visitor->trace(m_multipartParser);
     Resource::trace(visitor);
     ImageObserver::trace(visitor);
     MultipartImageResourceParser::Client::trace(visitor);
 }
 
-void ImageResource::notifyObserver(ImageResourceObserver* observer, bool isNotifyingFinish, const IntRect* changeRect)
+void ImageResource::checkNotify()
 {
-    if (isNotifyingFinish) {
+    if (isLoading())
+        return;
+
+    ImageResourceObserverWalker walker(m_observers);
+    while (auto* observer = walker.next()) {
         observer->imageNotifyFinished(this);
-        if (m_observers.contains(observer)) {
-            m_finishedObservers.add(observer);
-            m_observers.remove(observer);
+    }
+
+    Resource::checkNotify();
+}
+
+void ImageResource::markClientsAndObserversFinished()
+{
+    while (!m_observers.isEmpty()) {
+        HashCountedSet<ImageResourceObserver*>::iterator it = m_observers.begin();
+        for (int i = it->value; i; i--) {
+            m_finishedObservers.add(it->key);
+            m_observers.remove(it);
         }
     }
 
-    observer->imageChanged(this, changeRect);
+    Resource::markClientsAndObserversFinished();
 }
 
 void ImageResource::addObserver(ImageResourceObserver* observer)
 {
     willAddClientOrObserver();
 
     m_observers.add(observer);
 
     if (!m_revalidatingRequest.isNull())
         return;
 
     if (m_data && !m_image && !errorOccurred()) {
         createImage();
         m_image->setData(m_data, true);
     }
 
     if (m_image && !m_image->isNull()) {
-        bool isNotifyingFinish = !isLoading() && !stillNeedsLoad();
-        notifyObserver(observer, isNotifyingFinish);
+        observer->imageChanged(this);
+    }
+
+    if (isLoaded()) {
+        observer->imageNotifyFinished(this);
+        if (m_observers.contains(observer)) {
+            m_finishedObservers.add(observer);
+            m_observers.remove(observer);
+        }
     }
 }
 
 void ImageResource::removeObserver(ImageResourceObserver* observer)
 {
     ASSERT(observer);
 
     if (m_observers.contains(observer))
         m_observers.remove(observer);
     else if (m_finishedObservers.contains(observer))
@@ skipping 141 matching lines @@
         return size;
 
     // Don't let images that have a width/height >= 1 shrink below 1 when zoomed.
     LayoutSize minimumSize(size.width() > LayoutUnit() ? LayoutUnit(1) : LayoutUnit(),
         LayoutUnit(size.height() > LayoutUnit() ? LayoutUnit(1) : LayoutUnit()));
     size.scale(multiplier);
     size.clampToMinimumSize(minimumSize);
     return size;
 }
 
-void ImageResource::notifyObservers(bool isNotifyingFinish, const IntRect* changeRect)
+void ImageResource::notifyObservers(const IntRect* changeRect)
 {
     ImageResourceObserverWalker finishedWalker(m_finishedObservers);
     while (auto* observer = finishedWalker.next()) {
-        notifyObserver(observer, false, changeRect);
+        observer->imageChanged(this, changeRect);
     }
 
     ImageResourceObserverWalker walker(m_observers);
     while (auto* observer = walker.next()) {
-        notifyObserver(observer, isNotifyingFinish, changeRect);
+        observer->imageChanged(this, changeRect);
     }
 }
 
 void ImageResource::clear()
 {
     prune();
     clearImage();
     setEncodedSize(0);
 }
 
@@ skipping 49 matching lines @@
     if (sizeAvailable || allDataReceived) {
         if (!m_image || m_image->isNull()) {
             error(errorOccurred() ? getStatus() : DecodeError);
             if (memoryCache()->contains(this))
                 memoryCache()->remove(this);
             return;
         }
 
         // It would be nice to only redraw the decoded band of the image, but with the current design
         // (decoding delayed until painting) that seems hard.
-        notifyObservers(allDataReceived);
+        notifyObservers();
     }
 }
 
 void ImageResource::finish()
 {
     if (m_multipartParser) {
         m_multipartParser->finish();
         if (m_data) {
             clearImage();
             updateImage(true);
             m_data.clear();
         }
     } else {
         updateImage(true);
     }
     Resource::finish();
 }
 
 void ImageResource::error(Resource::Status status)
 {
     if (m_multipartParser)
         m_multipartParser->cancel();
     clear();
     Resource::error(status);
-    notifyObservers(true);
+    notifyObservers();
 }
 
 void ImageResource::responseReceived(const ResourceResponse& response, PassOwnPtr<WebDataConsumerHandle> handle)
 {
     ASSERT(!handle);
     ASSERT(!m_multipartParser);
     // If there's no boundary, just handle the request normally.
     if (response.isMultipart() && !response.multipartBoundary().isEmpty())
         m_multipartParser = new MultipartImageResourceParser(response, response.multipartBoundary(), this);
     Resource::responseReceived(response, handle);
@@ skipping 45 matching lines @@
             return false;
     }
 
     return true;
 }
 
 void ImageResource::animationAdvanced(const blink::Image* image)
 {
     if (!image || image != m_image)
         return;
-    notifyObservers(false);
+    notifyObservers();
 }
 
 void ImageResource::updateImageAnimationPolicy()
 {
     if (!m_image)
         return;
 
     ImageAnimationPolicy newPolicy = ImageAnimationPolicyAllowed;
 
     ImageResourceObserverWalker finishedWalker(m_finishedObservers);
@@ skipping 21 matching lines @@
     m_resourceRequest.setCachePolicy(ResourceRequestCachePolicy::BypassingCache);
     m_resourceRequest.setLoFiState(WebURLRequest::LoFiOff);
     error(Resource::LoadError);
     load(fetcher);
 }
 
 void ImageResource::changedInRect(const blink::Image* image, const IntRect& rect)
 {
     if (!image || image != m_image)
         return;
-    notifyObservers(false, &rect);
+    notifyObservers(&rect);
 }
 
 void ImageResource::onePartInMultipartReceived(const ResourceResponse& response)
 {
     ASSERT(m_multipartParser);
 
     m_response = response;
     if (m_multipartParsingState == MultipartParsingState::WaitingForFirstPart) {
         // We have nothing to do because we don't have any data.
         m_multipartParsingState = MultipartParsingState::ParsingFirstPart;
@@ skipping 25 matching lines @@
     if (response().wasFetchedViaServiceWorker())
         return response().serviceWorkerResponseType() != WebServiceWorkerResponseTypeOpaque;
     if (!getImage()->currentFrameHasSingleSecurityOrigin())
         return false;
     if (passesAccessControlCheck(securityOrigin))
         return true;
     return !securityOrigin->taintsCanvas(response().url());
 }
 
 } // namespace blink