DO NOT SUBMIT really old prototype of sprite recognition for image replacement

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 25 matching lines @@
 
 namespace blink {
 
 class FetchRequest;
 class FloatSize;
 class ImageResourceObserver;
 class MemoryCache;
 class ResourceClient;
 class ResourceFetcher;
 class SecurityOrigin;
+class SubstituteData;
 
 // ImageResource class represents an image type resource.
 //
 // As for the lifetimes of m_image and m_data, see this document:
 // https://docs.google.com/document/d/1v0yTAZ6wkqX2U_M6BNIGUJpM1s0TIw1VsqpxoL7aciY/edit?usp=sharing
 class CORE_EXPORT ImageResource final : public Resource, public ImageObserver, public MultipartImageResourceParser::Client {
     friend class MemoryCache;
     USING_GARBAGE_COLLECTED_MIXIN(ImageResource);
 public:
     using ClientType = ResourceClient;
 
-    static ImageResource* fetch(FetchRequest&, ResourceFetcher*);
+    enum class PlaceholderRequestType {
+        DisallowPlaceholder = 0, // The image being requested must not be a placeholder.
+        AllowPlaceholder, // The image being requested is allowed to be a placeholder.
+    };
+    static ImageResource* fetch(FetchRequest&, ResourceFetcher*, PlaceholderRequestType = PlaceholderRequestType::DisallowPlaceholder);
 
     static ImageResource* create(blink::Image* image)
     {
         return new ImageResource(image, ResourceLoaderOptions());
     }
 
     static ImageResource* create(const ResourceRequest& request)
     {
-        return new ImageResource(request, ResourceLoaderOptions());
+        return new ImageResource(request, ResourceLoaderOptions(), request, false /* isPlaceholder */);
     }
 
     ~ImageResource() override;
 
     blink::Image* getImage(); // Returns the nullImage() if the image is not available yet.
     bool hasImage() const { return m_image.get(); }
 
     static std::pair<blink::Image*, float> brokenImage(float deviceScaleFactor); // Returns an image and the image's resolution scale factor.
     bool willPaintBrokenImage() const;
 
@@ skipping 45 matching lines @@
     void didDraw(const blink::Image*) override;
 
     bool shouldPauseAnimation(const blink::Image*) override;
     void animationAdvanced(const blink::Image*) override;
     void changedInRect(const blink::Image*, const IntRect&) override;
 
     // MultipartImageResourceParser::Client
     void onePartInMultipartReceived(const ResourceResponse&) final;
     void multipartDataReceived(const char*, size_t) final;
 
+    const ResourceRequest& getOriginalResourceRequest() const { return m_originalRequest; }
+    bool isPlaceholder() const { return m_isPlaceholder; }
+
     DECLARE_VIRTUAL_TRACE();
 
 private:
+    class PlaceholderLoaderJob;
+
     explicit ImageResource(blink::Image*, const ResourceLoaderOptions&);
 
     enum class MultipartParsingState : uint8_t {
         WaitingForFirstPart,
         ParsingFirstPart,
         FinishedParsingFirstPart,
     };
 
     class ImageResourceFactory : public ResourceFactory {
     public:
-        ImageResourceFactory()
-            : ResourceFactory(Resource::Image) { }
+        // Construct a new ImageResourceFactory.
+        ImageResourceFactory(bool isPlaceholder)
+            : ResourceFactory(Resource::Image)
+            , m_isPlaceholder(isPlaceholder)
+        {
+        }
 
-        Resource* create(const ResourceRequest& request, const ResourceLoaderOptions& options, const String&) const override
-        {
-            return new ImageResource(request, options);
-        }
+        Resource* create(const ResourceRequest&, const ResourceLoaderOptions&, const String&) const override;
+
+    private:
+        bool m_isPlaceholder;
     };
-    ImageResource(const ResourceRequest&, const ResourceLoaderOptions&);
+    ImageResource(const ResourceRequest&, const ResourceLoaderOptions&, const ResourceRequest& originalRequest, bool isPlaceholder);
 
     bool hasClientsOrObservers() const override { return Resource::hasClientsOrObservers() || !m_observers.isEmpty() || !m_finishedObservers.isEmpty(); }
     void clear();
 
     void createImage();
     void updateImage(bool allDataReceived);
     void updateImageAndClearBuffer();
     void clearImage();
     // If not null, changeRect is the changed part of the image.
     void notifyObservers(const IntRect* changeRect = nullptr);
 
     void ensureImage();
 
     void checkNotify() override;
     void notifyObserversInternal(MarkFinishedOption);
     void markObserverFinished(ImageResourceObserver*);
 
     void doResetAnimation();
 
     void destroyDecodedDataIfPossible() override;
     void destroyDecodedDataForFailedRevalidation() override;
 
+    void setIsPlaceholder(bool isPlaceholder) { m_isPlaceholder = isPlaceholder; }
+
+    // Reload the image using the given ResourceFetcher and ResourceRequest. If
+    // valid SubstituteData is provided, then the load will complete
+    // synchronously with a 200 response for the given SubstituteData.
+    void reload(ResourceFetcher*, const ResourceRequest&, const SubstituteData&);
+
     float m_devicePixelRatioHeaderValue;
 
     Member<MultipartImageResourceParser> m_multipartParser;
     RefPtr<blink::Image> m_image;
     MultipartParsingState m_multipartParsingState = MultipartParsingState::WaitingForFirstPart;
     bool m_hasDevicePixelRatioHeaderValue;
     HashCountedSet<ImageResourceObserver*> m_observers;
     HashCountedSet<ImageResourceObserver*> m_finishedObservers;
+
+    // The original ResourceRequest, before making any modifications for
+    // fetching placeholders (e.g. adding Range request headers, etc.). This is
+    // used by the PlaceholderLoaderJob to reset the ResourceRequest to its
+    // original contents while attempting to fetch different states of
+    // placeholder images. This needs to outlive the |m_placeholderLoaderJob| so
+    // that an ImageResource that has finished loading can still be reloaded and
+    // replaced with the full image.
+    ResourceRequest m_originalRequest;
+
+    // Set to true if the image is a placeholder or if the ImageResource is
+    // currently attempting to fetch and construct a placeholder image.
+    bool m_isPlaceholder;
+
+    // The job responsible for managing loading a placeholder image. This will
+    // only be non-null while a placeholder image is being loaded.
+    Member<PlaceholderLoaderJob> m_placeholderLoaderJob;
+
+    // Flag indicating that the ImageResource is currently scheduling a reload
+    // operation. When this flag is set, no observers should be notified of
+    // image completion or marked as finished, to avoid notifying observers that
+    // the image is finished before the loading process is complete, e.g. if a
+    // placeholder or Lo-Fi image is being reloaded before the original load
+    // completes.
+    bool m_isSchedulingReload;
 };
 
 DEFINE_RESOURCE_TYPE_CASTS(Image);
 
 } // namespace blink
 
 #endif