Phase III Step 2: Call imageNotifyFinished() and image load event after SVG loading completes

third_party/WebKit/Source/core/loader/resource/ImageResourceContent.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/resource/ImageResourceContent.h"
 
 #include <memory>
 
 #include "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ImageResourceInfo.h"
@@ skipping 299 matching lines @@
         m_status = ResourceStatus::Cached;
       }
       break;
     case DoNotNotifyFinish:
       if (m_status == ResourceStatus::NotStarted)
         m_status = ResourceStatus::Pending;
       break;
   }
 }
 
+void ImageResourceContent::loadCompleted(const blink::Image* image) {
+  if (m_image != image)
+    return;
+  CHECK_EQ(m_sizeAvailable, Image::SizeAvailableAndLoadingAsynchronously);
+  m_sizeAvailable = Image::SizeAvailable;
+  updateStatus(ResourceStatus::Cached, ShouldNotifyFinish);
+  notifyObservers(ShouldNotifyFinish);
+}
+
 ImageResourceContent::UpdateImageResult ImageResourceContent::updateImage(
     PassRefPtr<SharedBuffer> data,
     ResourceStatus status,
     UpdateImageOption updateImageOption,
     bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
 #if DCHECK_IS_ON()
   DCHECK(!m_isUpdateImageBeingCalled);
   AutoReset<bool> scope(&m_isUpdateImageBeingCalled, true);
@@ skipping 18 matching lines @@
     case UpdateImage:
     case ClearAndUpdateImage:
       // Have the image update its data from its internal buffer. It will not do
       // anything now, but will delay decoding until queried for info (like size
       // or specific image frames).
       if (data) {
         if (!m_image)
           m_image = createImage();
         DCHECK(m_image);
         m_sizeAvailable = m_image->setData(std::move(data), allDataReceived);
+        if (!allDataReceived) {
+          DCHECK_NE(m_sizeAvailable,
+                    Image::SizeAvailableAndLoadingAsynchronously);
+        }
       }
 
       // Go ahead and tell our observers to try to draw if we have either
       // received all the data or the size is known. Each chunk from the network
       // causes observers to repaint, which will force that chunk to decode.
       if (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived) {
         updateStatus(status, DoNotNotifyFinish);
         return UpdateImageResult::NoDecodeError;
       }
 
@@ skipping 11 matching lines @@
         return UpdateImageResult::ShouldDecodeError;
       }
       break;
   }
 
   // Notifies the observers.
   // 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.
 
   NotifyFinishOption notifyFinishOption =
-      allDataReceived ? ShouldNotifyFinish : DoNotNotifyFinish;
+      allDataReceived &&
+              m_sizeAvailable != Image::SizeAvailableAndLoadingAsynchronously
+          ? ShouldNotifyFinish
+          : DoNotNotifyFinish;
   updateStatus(status, notifyFinishOption);
   notifyObservers(notifyFinishOption);
   return UpdateImageResult::NoDecodeError;
 }
 
 void ImageResourceContent::notifyStartLoad() {
   m_status = ResourceStatus::Pending;
 }
 
 void ImageResourceContent::decodedSizeChangedTo(const blink::Image* image,
@@ skipping 109 matching lines @@
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
 
 }  // namespace blink