Phase II Step 3: Reload LoFi/placeholder images via new ImageResource

third_party/WebKit/Source/core/fetch/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/fetch/ImageResourceContent.h"
 
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ImageResourceInfo.h"
 #include "core/fetch/ImageResourceObserver.h"
 #include "core/svg/graphics/SVGImage.h"
@@ skipping 17 matching lines @@
       public ImageResourceInfo {
   USING_GARBAGE_COLLECTED_MIXIN(NullImageResourceInfo);
 
  public:
   NullImageResourceInfo() {}
 
   DEFINE_INLINE_VIRTUAL_TRACE() { ImageResourceInfo::trace(visitor); }
 
  private:
   const KURL& url() const override { return m_url; }
-  bool isSchedulingReload() const override { return false; }
   bool hasDevicePixelRatioHeaderValue() const override { return false; }
   float devicePixelRatioHeaderValue() const override { return 1.0; }
   const ResourceResponse& response() const override { return m_response; }
   ResourceStatus getStatus() const override { return ResourceStatus::Cached; }
   bool isPlaceholder() const override { return false; }
   bool isCacheValidator() const override { return false; }
-  bool schedulingReloadOrShouldReloadBrokenPlaceholder() const override {
-    return false;
-  }
+  bool shouldReloadBrokenPlaceholder() const override { return false; }
   bool isAccessAllowed(
       SecurityOrigin*,
       bool doesCurrentFrameHasSingleSecurityOrigin) const override {
     return true;
   }
   bool hasCacheControlNoStoreHeader() const override { return false; }
   const ResourceError& resourceError() const override { return m_error; }
+  ImageResource* resourceForTest() const override { return nullptr; }
 
   const KURL m_url;
   const ResourceResponse m_response;
   const ResourceError m_error;
 };
 
 }  // namespace
 
 class ResourceFetcher;
 
@@ skipping 34 matching lines @@
 
   m_observers.add(observer);
 
   if (m_info->isCacheValidator())
     return;
 
   if (m_image && !m_image->isNull()) {
     observer->imageChanged(this);
   }
 
-  if (isLoaded() && m_observers.contains(observer) &&
-      !m_info->schedulingReloadOrShouldReloadBrokenPlaceholder()) {
+  if (isLoaded() && m_observers.contains(observer)) {
     markObserverFinished(observer);
     observer->imageNotifyFinished(this);
   }
 }
 
 void ImageResourceContent::removeObserver(ImageResourceObserver* observer) {
   DCHECK(observer);
 
   if (m_observers.contains(observer))
     m_observers.remove(observer);
@@ skipping 120 matching lines @@
     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)) {
       observer->imageChanged(this, changeRect);
       if (notifyingFinishOption == ShouldNotifyFinish &&
-          m_observers.contains(observer) &&
-          !m_info->schedulingReloadOrShouldReloadBrokenPlaceholder()) {
+          m_observers.contains(observer)) {
         markObserverFinished(observer);
         observer->imageNotifyFinished(this);
       }
     }
   }
 }
 
 inline PassRefPtr<Image> ImageResourceContent::createImage() {
   if (m_info->response().mimeType() == "image/svg+xml")
     return SVGImage::create(this);
   return BitmapImage::create(this);
 }
 
 inline void ImageResourceContent::clearImage() {
   if (!m_image)
     return;
   int64_t length = m_image->data() ? m_image->data()->size() : 0;
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-length);
 
   // If our Image has an observer, it's always us so we need to clear the back
   // pointer before dropping our reference.
   m_image->clearImageObserver();
   m_image.clear();
   m_sizeAvailable = Image::SizeUnavailable;
 }
 
 void ImageResourceContent::updateImage(PassRefPtr<SharedBuffer> data,
                                        ClearImageOption clearImageOption,
-                                       bool allDataReceived) {
+                                       bool allDataReceived,
+                                       ResourceFetcher* fetcherForReload) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
   if (clearImageOption == ImageResourceContent::ClearExistingImage) {
     clearImage();
   }
 
   // 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) {
@@ skipping 19 matching lines @@
 
       clearImage();
       m_image = PlaceholderImage::create(this, dimensions);
     } else {
       // Clear the image so that it gets treated like a decoding error, since
       // the attempt to build a placeholder image failed.
       clearImage();
     }
   }
 
+  if (m_info->shouldReloadBrokenPlaceholder()) {
+    if (m_info->reloadIfLoFiOrPlaceholder(fetcherForReload))
+      return;
+  }
+
   if (!m_image || m_image->isNull()) {
     clearImage();
     m_info->decodeError(allDataReceived);
   }
 
   // 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(allDataReceived ? ShouldNotifyFinish : DoNotNotifyFinish);
 }
 
@@ skipping 108 matching lines @@
   return m_info->hasDevicePixelRatioHeaderValue();
 }
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
+ImageResource* ImageResourceContent::resourceForTest() const {
+  return m_info->resourceForTest();
+}
 
 }  // namespace blink