[ImageResource 0b] Decouple ImageResourceObserver::imageNotifyFinished() from 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 129 matching lines @@
 }
 
 DEFINE_TRACE(ImageResource) {
   visitor->trace(m_multipartParser);
   Resource::trace(visitor);
   ImageObserver::trace(visitor);
   MultipartImageResourceParser::Client::trace(visitor);
 }
 
 void ImageResource::checkNotify() {
-  // Don't notify observers and clients of completion if this ImageResource is
+  // Don't notify clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
-  notifyObserversInternal();
   Resource::checkNotify();
 }
 
-void ImageResource::notifyObserversInternal() {
-  if (isLoading())
-    return;
-
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer)) {
-      markObserverFinished(observer);
-      observer->imageNotifyFinished(this);
-    }
-  }
-}
-
 void ImageResource::markObserverFinished(ImageResourceObserver* observer) {
   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);
 
@@ skipping 20 matching lines @@
   // On the other hand, when the response is multipart, |updateImage()| is 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() && !m_isSchedulingReload && !shouldReloadBrokenPlaceholder()) {
+  if (isLoaded() && m_observers.contains(observer) && !m_isSchedulingReload &&
+      !shouldReloadBrokenPlaceholder()) {
     markObserverFinished(observer);
     observer->imageNotifyFinished(this);
   }
 }
 
 void ImageResource::removeObserver(ImageResourceObserver* observer) {
   DCHECK(observer);
 
   if (m_observers.contains(observer))
     m_observers.remove(observer);
@@ skipping 194 matching lines @@
 
   // 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(const IntRect* changeRect) {
+void ImageResource::notifyObservers(NotifyFinishOption notifyingFinishOption,
+                                    const IntRect* changeRect) {
   for (auto* observer : m_finishedObservers.asVector()) {
     if (m_finishedObservers.contains(observer))
       observer->imageChanged(this, changeRect);
   }
   for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer))
+    if (m_observers.contains(observer)) {
       observer->imageChanged(this, changeRect);
+      if (notifyingFinishOption == ShouldNotifyFinish &&
+          m_observers.contains(observer) && !m_isSchedulingReload &&
+          !shouldReloadBrokenPlaceholder()) {
+        markObserverFinished(observer);
+        observer->imageNotifyFinished(this);
+      }
+    }
   }
 }
 
 void ImageResource::clear() {
   clearImage();
   clearData();
   setEncodedSize(0);
 }
 
 inline void ImageResource::createImage() {
@@ skipping 62 matching lines @@
     if (!errorOccurred())
       setStatus(DecodeError);
     if (!allDataReceived && loader()) {
       loader()->didFinishLoading(monotonicallyIncreasingTime(), size, size);
     }
     memoryCache()->remove(this);
   }
 
   // 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();
+  notifyObservers(allDataReceived ? ShouldNotifyFinish : DoNotNotifyFinish);
 }
 
 void ImageResource::updateImageAndClearBuffer() {
   clearImage();
   updateImage(true);
   clearData();
 }
 
 void ImageResource::finish(double loadFinishTime) {
   if (m_multipartParser) {
@@ skipping 10 matching lines @@
     clearData();
   }
   Resource::finish(loadFinishTime);
 }
 
 void ImageResource::error(const ResourceError& error) {
   if (m_multipartParser)
     m_multipartParser->cancel();
   clear();
   Resource::error(error);
-  notifyObservers();
+  notifyObservers(ShouldNotifyFinish);
 }
 
 void ImageResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!handle);
   DCHECK(!m_multipartParser);
   // If there's no boundary, just handle the request normally.
   if (response.isMultipart() && !response.multipartBoundary().isEmpty()) {
     m_multipartParser = new MultipartImageResourceParser(
@@ skipping 34 matching lines @@
     if (m_observers.contains(observer) && observer->willRenderImage())
       return false;
   }
 
   return true;
 }
 
 void ImageResource::animationAdvanced(const blink::Image* image) {
   if (!image || image != m_image)
     return;
-  notifyObservers();
+  notifyObservers(DoNotNotifyFinish);
 }
 
 void ImageResource::updateImageAnimationPolicy() {
   if (!m_image)
     return;
 
   ImageAnimationPolicy newPolicy = ImageAnimationPolicyAllowed;
   for (auto* observer : m_finishedObservers.asVector()) {
     if (m_finishedObservers.contains(observer) &&
         observer->getImageAnimationPolicy(newPolicy))
@@ skipping 42 matching lines @@
     clearRangeRequestHeader();
   }
 
   if (isLoading()) {
     loader()->cancel();
     // Canceling the loader causes error() to be called, which in turn calls
     // clear() and notifyObservers(), so there's no need to call these again
     // here.
   } else {
     clear();
-    notifyObservers();
+    notifyObservers(DoNotNotifyFinish);
   }
 
   setStatus(NotStarted);
 
   DCHECK(m_isSchedulingReload);
   m_isSchedulingReload = false;
 
   fetcher->startLoad(this);
 }
 
 void ImageResource::changedInRect(const blink::Image* image,
                                   const IntRect& rect) {
   if (!image || image != m_image)
     return;
-  notifyObservers(&rect);
+  notifyObservers(DoNotNotifyFinish, &rect);
 }
 
 void ImageResource::onePartInMultipartReceived(
     const ResourceResponse& response) {
   DCHECK(m_multipartParser);
 
   setResponse(response);
   if (m_multipartParsingState == MultipartParsingState::WaitingForFirstPart) {
     // We have nothing to do because we don't have any data.
     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);
-    // We notify clients/observers of finish here, and they will not be
+    // We notify clients and observers of finish in checkNotify() and
+    // updateImageAndClearBuffer(), respectively, and they will not be
     // notified again in Resource::finish()/error().
     checkNotify();
     if (loader())
       loader()->didFinishLoadingFirstPartInMultipart();
   }
 }
 
 void ImageResource::multipartDataReceived(const char* bytes, size_t size) {
   DCHECK(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