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 380 matching lines @@
     case ResourceStatus::kCached:
     case ResourceStatus::kLoadError:
     case ResourceStatus::kDecodeError:
       // Load start due to revalidation/reload.
       break;
   }
 
   content_status_ = ResourceStatus::kPending;
 }
 
+void ImageResourceContent::LoadCompleted(const blink::Image* image) {
+  if (image_ != image)
+    return;
+  CHECK_EQ(size_available_, Image::kSizeAvailableAndLoadingAsynchronously);
+  size_available_ = Image::kSizeAvailable;
+  UpdateToLoadedContentStatus(ResourceStatus::kCached);
+  NotifyObservers(kShouldNotifyFinish);
+}
+
 ImageResourceContent::UpdateImageResult ImageResourceContent::UpdateImage(
     PassRefPtr<SharedBuffer> data,
     ResourceStatus status,
     UpdateImageOption update_image_option,
     bool all_data_received) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
 #if DCHECK_IS_ON()
   DCHECK(!is_update_image_being_called_);
   AutoReset<bool> scope(&is_update_image_being_called_, true);
@@ skipping 20 matching lines @@
     case kUpdateImage:
     case kClearAndUpdateImage:
       // 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 (!image_)
           image_ = CreateImage();
         DCHECK(image_);
         size_available_ = image_->SetData(std::move(data), all_data_received);
+        if (!all_data_received) {
+          DCHECK_NE(size_available_,
+                    Image::kSizeAvailableAndLoadingAsynchronously);
+        }
       }
 
       // 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 (size_available_ == Image::kSizeUnavailable && !all_data_received)
         return UpdateImageResult::kNoDecodeError;
 
       if (info_->ShouldShowPlaceholder() && all_data_received) {
         if (image_ && !image_->IsNull()) {
           IntSize dimensions = image_->Size();
           ClearImage();
           image_ = PlaceholderImage::Create(this, dimensions);
         }
       }
 
       if (!image_ || image_->IsNull()) {
         ClearImage();
         return UpdateImageResult::kShouldDecodeError;
       }
       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.
-
-  if (all_data_received) {
+  if (all_data_received &&
+      size_available_ != Image::kSizeAvailableAndLoadingAsynchronously) {

[fs, 2017/05/05 10:52:42]

Nit: Maybe add a short comment about this additional part of the condition (it
may not be 100% obvious.)

[hiroshige, 2017/05/08 17:22:06]

Done.

     UpdateToLoadedContentStatus(status);
     NotifyObservers(kShouldNotifyFinish);
   } else {
     NotifyObservers(kDoNotNotifyFinish);
   }
 
   return UpdateImageResult::kNoDecodeError;
 }
 
 void ImageResourceContent::DecodedSizeChangedTo(const blink::Image* image,
@@ skipping 115 matching lines @@
 
 const ResourceResponse& ImageResourceContent::GetResponse() const {
   return info_->GetResponse();
 }
 
 const ResourceError& ImageResourceContent::GetResourceError() const {
   return info_->GetResourceError();
 }
 
 }  // namespace blink