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

third_party/WebKit/Source/core/fetch/ImageResource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@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
     version 2 of the License, or (at your option) any later version.
@@ skipping 53 matching lines @@
   ImageResourceContent* getContent() const;
 
   enum class ReloadCachePolicy {
     UseExistingPolicy = 0,  // Don't modify the request's cache policy.
     BypassCache,  // Modify the request so that the reload bypasses the cache.
   };
 
   // If this ImageResource has the Lo-Fi response headers or is a placeholder,
   // reload the full original image with the Lo-Fi state set to off and
   // optionally bypassing the cache.
-  void reloadIfLoFiOrPlaceholder(
+  // Returns a new ImageResource that is used for reloading if reloading is
+  // started, and the original ImageResourceContent is attached to the new
+  // ImageResource. The original ImageResource shouldn't be used anymore.
+  ImageResource* reloadIfLoFiOrPlaceholder(
       ResourceFetcher*,
       ReloadCachePolicy = ReloadCachePolicy::BypassCache);
 
   void didAddClient(ResourceClient*) override;
 
   ResourcePriority priorityFromObservers() override;
 
   void allClientsAndObserversRemoved() override;
 
   PassRefPtr<const SharedBuffer> resourceBuffer() const override;
   void appendData(const char*, size_t) override;
-  void error(const ResourceError&) override;
+  void error(const ResourceError&, ResourceFetcher* fetcherForReload) override;
   void responseReceived(const ResourceResponse&,
                         std::unique_ptr<WebDataConsumerHandle>) override;
-  void finish(double finishTime = 0.0) override;
+  void finish(double finishTime = 0.0,
+              ResourceFetcher* fetcherForReload = nullptr) override;
 
   // For compatibility, images keep loading even if there are HTTP errors.
   bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }
 
   bool isImage() const override { return true; }
 
   // MultipartImageResourceParser::Client
   void onePartInMultipartReceived(const ResourceResponse&) final;
   void multipartDataReceived(const char*, size_t) final;
 
@@ skipping 23 matching lines @@
 
   ImageResource(const ResourceRequest&,
                 const ResourceLoaderOptions&,
                 ImageResourceContent*,
                 bool isPlaceholder);
 
   bool hasClientsOrObservers() const override;
 
   void updateImageAndClearBuffer();
 
-  void checkNotify() override;
-
   void destroyDecodedDataIfPossible() override;
   void destroyDecodedDataForFailedRevalidation() override;
 
   // When ClearImageOption is KeepExistingImage but this is the first
   // updateImage() call, then ClearExistingImage is used instead to enforce
   // new image creation.
   void updateImage(PassRefPtr<SharedBuffer>,
                    ImageResourceContent::ClearImageOption,
-                   bool allDataReceived);
+                   bool allDataReceived,
+                   ResourceFetcher* fetcherForReload = nullptr);
   void flushImageIfNeeded(TimerBase*);
 
   bool willPaintBrokenImage() const;
 
+  void detachContent();
+
   Member<ImageResourceContent> m_content;
 
   // Indicates whether updateImage() is called for this resource, or for this
   // part (in case of multipart images), and is used for enforcing creation of
   // new blink::Image in ImageResourceContent for the first updateImage().
   bool m_isUpdateImageCalled = false;
 
   float m_devicePixelRatioHeaderValue;
 
   Member<MultipartImageResourceParser> m_multipartParser;
   MultipartParsingState m_multipartParsingState =
       MultipartParsingState::WaitingForFirstPart;
   bool m_hasDevicePixelRatioHeaderValue;
 
-  // Indicates if the ImageResource is currently scheduling a reload, e.g.
-  // because reloadIfLoFi() was called.
-  bool m_isSchedulingReload;
-
   // Indicates if this ImageResource is either attempting to load a placeholder
   // image, or is a (possibly broken) placeholder image.
   bool m_isPlaceholder;
 
   Timer<ImageResource> m_flushTimer;
   double m_lastFlushTime = 0.;
 };
 
 DEFINE_RESOURCE_TYPE_CASTS(Image);
 
 }  // namespace blink
 
 #endif