Mark ResourceClient/ImageResourceObserver finished just before notifying

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 77 matching lines @@
 DEFINE_TRACE(ImageResource)
 {
     visitor->trace(m_multipartParser);
     Resource::trace(visitor);
     ImageObserver::trace(visitor);
     MultipartImageResourceParser::Client::trace(visitor);
 }
 
 void ImageResource::checkNotify()
 {
+    notifyObserversInternal(MarkFinishedOption::ShouldMarkFinished);
+    Resource::checkNotify();
+}
+
+void ImageResource::notifyObserversInternal(MarkFinishedOption markFinishedOption)
+{
     if (isLoading())
         return;
 
     ImageResourceObserverWalker walker(m_observers);
     while (auto* observer = walker.next()) {
+        if (markFinishedOption == MarkFinishedOption::ShouldMarkFinished)
+            markObserverFinished(observer);
         observer->imageNotifyFinished(this);
     }
-
-    Resource::checkNotify();
 }
 
-void ImageResource::markClientsAndObserversFinished()
+void ImageResource::markObserverFinished(ImageResourceObserver* observer)
 {
-    HashCountedSet<ImageResourceObserver*> observers;
-    m_observers.swap(observers);
-    for (const auto& it : observers)
-        m_finishedObservers.add(it.key, it.value);
-
-    Resource::markClientsAndObserversFinished();
+    if (m_observers.contains(observer)) {
+        m_finishedObservers.add(observer);
+        m_observers.remove(observer);
+    }
 }
 
 void ImageResource::didAddClient(ResourceClient* client)
 {
     DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
     Resource::didAddClient(client);
 }
 
 void ImageResource::addObserver(ImageResourceObserver* observer)
 {
@@ skipping 12 matching lines @@
     // not called in |appendData()|, which means |m_image| might not be created
     // even when |data()| exists. This is intentional since creating a |m_image|
     // on receiving data might destroy an existing image in a previous part.
     DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
 
     if (m_image && !m_image->isNull()) {
         observer->imageChanged(this);
     }
 
     if (isLoaded()) {
+        markObserverFinished(observer);
         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 410 matching lines @@
         m_multipartParsingState = MultipartParsingState::ParsingFirstPart;
         return;
     }
     updateImageAndClearBuffer();
 
     if (m_multipartParsingState == MultipartParsingState::ParsingFirstPart) {
         m_multipartParsingState = MultipartParsingState::FinishedParsingFirstPart;
         // Notify finished when the first part ends.
         if (!errorOccurred())
             setStatus(Cached);
-        checkNotify();
+        // We will also notify clients/observers of the finish in
+        // Resource::finish()/error() so we don't mark them finished here.
+        notifyObserversInternal(MarkFinishedOption::DoNotMarkFinished);
+        notifyClientsInternal(MarkFinishedOption::DoNotMarkFinished);
         if (loader())
             loader()->didFinishLoadingFirstPartInMultipart();
     }
 }
 
 void ImageResource::multipartDataReceived(const char* bytes, size_t size)
 {
     ASSERT(m_multipartParser);
     Resource::appendData(bytes, size);
 }
 
 bool ImageResource::isAccessAllowed(SecurityOrigin* securityOrigin)
 {
     if (response().wasFetchedViaServiceWorker())
         return response().serviceWorkerResponseType() != WebServiceWorkerResponseTypeOpaque;
     if (!getImage()->currentFrameHasSingleSecurityOrigin())
         return false;
     if (passesAccessControlCheck(securityOrigin))
         return true;
     return !securityOrigin->taintsCanvas(response().url());
 }
 
 } // namespace blink