[ImageResource 4] Split ImageResource into Resource and Image parts

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.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef ImageResource_h
 #define ImageResource_h
 
 #include "core/CoreExport.h"
+#include "core/fetch/ImageResourceContentInterface.h"
 #include "core/fetch/MultipartImageResourceParser.h"
 #include "core/fetch/Resource.h"
-#include "platform/geometry/IntRect.h"
-#include "platform/geometry/IntSizeHash.h"
-#include "platform/geometry/LayoutSize.h"
-#include "platform/graphics/Image.h"
-#include "platform/graphics/ImageObserver.h"
-#include "platform/graphics/ImageOrientation.h"
-#include "wtf/HashMap.h"
 #include <memory>
 
 namespace blink {
 
 class FetchRequest;
-class ImageResourceObserver;
 class MemoryCache;
 class ResourceClient;
 class ResourceFetcher;
 class SecurityOrigin;
+class ImageResourceContent;
 
-// ImageResource class represents an image type resource.
+// ImageResource is the resource-related part of image loading.
+// Image-related things (blink::Image and ImageResourceObserver) are handled by
+// ImageResourceContent.
+// Most users should use ImageResourceContent instead of ImageResource.
+// https://docs.google.com/document/d/1O-fB83mrE0B_V8gzXNqHgmRLCvstTB4MMi3RnVLr8bE/edit?usp=sharing
 //
-// As for the lifetimes of m_image and m_data, see this document:
+// As for the lifetimes of ImageResourceContent::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;
 
+  // Use ImageResourceContent::fetch() unless ImageResource is required.
   static ImageResource* fetch(FetchRequest&, ResourceFetcher*);
 
-  static ImageResource* create(blink::Image* image) {
-    return new ImageResource(image, ResourceLoaderOptions());
-  }
-
-  static ImageResource* create(const ResourceRequest& request) {
-    return new ImageResource(request, ResourceLoaderOptions(), false);
-  }
+  // TODO(hiroshige): Make create() test-only by refactoring ImageDocument.
+  static ImageResource* create(const ResourceRequest&);
 
   ~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;
-
-  bool usesImageContainerSize() const;
-  bool imageHasRelativeSize() const;
-  // The device pixel ratio we got from the server for this image, or 1.0.
-  float devicePixelRatioHeaderValue() const {
-    return m_devicePixelRatioHeaderValue;
-  }
-  bool hasDevicePixelRatioHeaderValue() const {
-    return m_hasDevicePixelRatioHeaderValue;
-  }
-
-  enum SizeType {
-    // Report the intrinsic size.
-    IntrinsicSize,
-
-    // Report the intrinsic size corrected to account for image density.
-    IntrinsicCorrectedToDPR,
-  };
-
-  // This method takes a zoom multiplier that can be used to increase the
-  // natural size of the image by the zoom.
-  LayoutSize imageSize(
-      RespectImageOrientationEnum shouldRespectImageOrientation,
-      float multiplier,
-      SizeType = IntrinsicSize);
-
-  bool isAccessAllowed(SecurityOrigin*);
-
-  void updateImageAnimationPolicy();
+  ImageResourceContentInterface* getContent() const;
+  ImageResourceContent* getRealContent() const;

[kinuko, 2016/12/01 16:40:55]

Having both methods here feels a bit confusing... and I'm a bit puzzled why we
need the Interface class.  Can we get rid of one of them?

[kinuko, 2016/12/01 16:40:55]

...ok I just read the comment about why you introduced it.  I'd +1 to merge them
into a single class at least for now / in this patch. (I'm deferring the final
decision to toyoshim / other reviewers though)

[hiroshige, 2016/12/02 08:51:17]

Discussed with toyoshim@ offline, and we conclude to remove
ImageResourceContentInterface because currently we don't have to clear the
dependencies around ImageResourceContent strictly (as we can move ImageResource
to core/loader/resource/).
I'll merge ImageResourceContentInterface and ImageResourceContent in the next
PatchSet.

 
   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(
       ResourceFetcher*,
       ReloadCachePolicy = ReloadCachePolicy::BypassCache);
 
   void didAddClient(ResourceClient*) override;
 
-  void addObserver(ImageResourceObserver*);
-  void removeObserver(ImageResourceObserver*);
-
   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 responseReceived(const ResourceResponse&,
                         std::unique_ptr<WebDataConsumerHandle>) override;
   void finish(double finishTime = 0.0) override;
 
   // For compatibility, images keep loading even if there are HTTP errors.
   bool shouldIgnoreHTTPStatusCodeErrors() const override { return true; }
 
   bool isImage() const override { return true; }
 
-  // ImageObserver
-  void decodedSizeChangedTo(const blink::Image*, size_t newSize) 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;
 
   // Used by tests.
   bool isPlaceholder() const { return m_isPlaceholder; }
 
   bool shouldReloadBrokenPlaceholder() const {
     return m_isPlaceholder && willPaintBrokenImage();
   }
 
-  void setNotRefetchableDataFromDiskCache() {
-    m_isRefetchableDataFromDiskCache = false;
-  }
-
   DECLARE_VIRTUAL_TRACE();
 
  private:
-  explicit ImageResource(blink::Image*, const ResourceLoaderOptions&);
+  // Only for ImageResourceInfoImpl.
+  void decodeError(bool allDataReceived);
+  bool isAccessAllowed(SecurityOrigin*,
+                       bool doesCurrentFrameHasSingleSecurityOrigin) const;
 
   enum class MultipartParsingState : uint8_t {
     WaitingForFirstPart,
     ParsingFirstPart,
     FinishedParsingFirstPart,
   };
 
+  class ImageResourceInfoImpl;
   class ImageResourceFactory;
 
   ImageResource(const ResourceRequest&,
                 const ResourceLoaderOptions&,
+                ImageResourceContent*,
                 bool isPlaceholder);
 
   bool hasClientsOrObservers() const override {
-    return Resource::hasClientsOrObservers() || !m_observers.isEmpty() ||
-           !m_finishedObservers.isEmpty();
+    return Resource::hasClientsOrObservers() || getContent()->hasObservers();
   }
-  void clear();
 
-  void createImage();
-  void updateImage(bool allDataReceived);
   void updateImageAndClearBuffer();
-  void clearImage();
-  enum NotifyFinishOption { ShouldNotifyFinish, DoNotNotifyFinish };
-  // If not null, changeRect is the changed part of the image.
-  void notifyObservers(NotifyFinishOption, const IntRect* changeRect = nullptr);
-
-  void ensureImage();
 
   void checkNotify() override;
-  void notifyObserversInternal();
-  void markObserverFinished(ImageResourceObserver*);
-
-  void doResetAnimation();
 
   void destroyDecodedDataIfPossible() override;
   void destroyDecodedDataForFailedRevalidation() override;
 
   void flushImageIfNeeded(TimerBase*);
 
+  bool willPaintBrokenImage() const;
+
+  Member<ImageResourceContent> m_content;
+
   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;
 
   // 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.;
-  Image::SizeAvailability m_sizeAvailable = Image::SizeUnavailable;
-
-  // Indicates if this resource's encoded image data can be purged and refetched
-  // from disk cache to save memory usage. See crbug/664437.
-  bool m_isRefetchableDataFromDiskCache;
 };
 
 DEFINE_RESOURCE_TYPE_CASTS(Image);
 
 }  // namespace blink
 
 #endif