Split ImageResourceClient into ResourceClient and ImageResourceObserver [2/2]

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)
+{
+    if (isNotifyingFinish) {
+        observer->imageNotifyFinished(this);
+        if (m_observers.contains(observer)) {
+            m_finishedObservers.add(observer);
+            m_observers.remove(observer);
+        }
+    }
+
+    observer->imageChanged(this, changeRect);
+}
+
 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())
-        observer->imageChanged(this);
+    if (m_image && !m_image->isNull()) {
+        bool isNotifyingFinish = !isLoading() && !stillNeedsLoad();
+        notifyObserver(observer, isNotifyingFinish);
+    }
 }
 
 void ImageResource::removeObserver(ImageResourceObserver* observer)
 {
     ASSERT(observer);
-    ASSERT(m_observers.contains(observer));
-    m_observers.remove(observer);
+
+    if (m_observers.contains(observer))
+        m_observers.remove(observer);
+    else if (m_finishedObservers.contains(observer))
+        m_finishedObservers.remove(observer);
+    else
+        ASSERT_NOT_REACHED();
+
     didRemoveClientOrObserver();
 }
 
+static void priorityFromObserver(const ImageResourceObserver* observer, ResourcePriority& priority)
+{
+    ResourcePriority nextPriority = observer->computeResourcePriority();
+    if (nextPriority.visibility == ResourcePriority::NotVisible)
+        return;
+    priority.visibility = ResourcePriority::Visible;
+    priority.intraPriorityValue += nextPriority.intraPriorityValue;
+}
+
 ResourcePriority ImageResource::priorityFromObservers()
 {
     ResourcePriority priority;
-    ImageResourceObserverWalker w(m_observers);
-    while (const auto* observer = w.next()) {
-        ResourcePriority nextPriority = observer->computeResourcePriority();
-        if (nextPriority.visibility == ResourcePriority::NotVisible)
-            continue;
-        priority.visibility = ResourcePriority::Visible;
-        priority.intraPriorityValue += nextPriority.intraPriorityValue;
+
+    ImageResourceObserverWalker finishedWalker(m_finishedObservers);
+    while (const auto* observer = finishedWalker.next()) {
+        priorityFromObserver(observer, priority);
     }
+
+    ImageResourceObserverWalker walker(m_observers);
+    while (const auto* observer = walker.next()) {
+        priorityFromObserver(observer, priority);
+    }
+
     return priority;
 }
 
 bool ImageResource::isSafeToUnlock() const
 {
     // Note that |m_image| holds a reference to |m_data| in addition to the one held by the Resource parent class.
     return !m_image || (m_image->hasOneRef() && m_data->refCount() == 2);
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation()
@@ skipping 101 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(const IntRect* changeRect)
+void ImageResource::notifyObservers(bool isNotifyingFinish, const IntRect* changeRect)
 {
-    ImageResourceObserverWalker w(m_observers);
-    while (auto* observer = w.next()) {
-        observer->imageChanged(this, changeRect);
+    ImageResourceObserverWalker finishedWalker(m_finishedObservers);
+    while (auto* observer = finishedWalker.next()) {
+        notifyObserver(observer, false, changeRect);
+    }
+
+    ImageResourceObserverWalker walker(m_observers);
+    while (auto* observer = walker.next()) {
+        notifyObserver(observer, isNotifyingFinish, 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();
+        notifyObservers(allDataReceived);
     }
 }
 
 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();
+    notifyObservers(true);
 }
 
 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 26 matching lines @@
     // to update MemoryCache.
     if (decodedSize() != 0)
         Resource::didAccessDecodedData();
 }
 
 bool ImageResource::shouldPauseAnimation(const blink::Image* image)
 {
     if (!image || image != m_image)
         return false;
 
-    ImageResourceObserverWalker w(m_observers);
-    while (auto* observer = w.next()) {
+    ImageResourceObserverWalker finishedWalker(m_finishedObservers);
+    while (auto* observer = finishedWalker.next()) {
         if (observer->willRenderImage())
             return false;
     }
+
+    ImageResourceObserverWalker walker(m_observers);
+    while (auto* observer = walker.next()) {
+        if (observer->willRenderImage())
+            return false;
+    }
+
     return true;
 }
 
 void ImageResource::animationAdvanced(const blink::Image* image)
 {
     if (!image || image != m_image)
         return;
-    notifyObservers();
+    notifyObservers(false);
 }
 
 void ImageResource::updateImageAnimationPolicy()
 {
     if (!m_image)
         return;
 
     ImageAnimationPolicy newPolicy = ImageAnimationPolicyAllowed;
-    ImageResourceObserverWalker w(m_observers);
-    while (auto* observer = w.next()) {
+
+    ImageResourceObserverWalker finishedWalker(m_finishedObservers);
+    while (auto* observer = finishedWalker.next()) {
         if (observer->getImageAnimationPolicy(newPolicy))
             break;
     }
+
+    ImageResourceObserverWalker walker(m_observers);
+    while (auto* observer = walker.next()) {
+        if (observer->getImageAnimationPolicy(newPolicy))
+            break;
+    }
 
     if (m_image->animationPolicy() != newPolicy) {
         m_image->resetAnimation();
         m_image->setAnimationPolicy(newPolicy);
     }
 }
 
 void ImageResource::reloadIfLoFi(ResourceFetcher* fetcher)
 {
     if (!m_response.httpHeaderField("chrome-proxy").contains("q=low"))
         return;
     m_resourceRequest.setCachePolicy(ResourceRequestCachePolicy::ReloadBypassingCache);
     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(&rect);
+    notifyObservers(false, &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