[ImageResource 4] Split ImageResource into Resource and Image parts

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@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.
 */
 
 #include "core/fetch/ImageResource.h"
 
-#include "core/fetch/ImageResourceObserver.h"
+#include "core/fetch/ImageResourceContent.h"
+#include "core/fetch/ImageResourceInfo.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceClient.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoadingLog.h"
-#include "core/svg/graphics/SVGImage.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
-#include "platform/geometry/IntSize.h"
-#include "platform/graphics/BitmapImage.h"
-#include "platform/graphics/PlaceholderImage.h"
 #include "platform/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCachePolicy.h"
 #include "wtf/CurrentTime.h"
-#include "wtf/HashCountedSet.h"
 #include "wtf/StdLibExtras.h"
-#include "wtf/Vector.h"
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 namespace {
 // The amount of time to wait before informing the clients that the image has
 // been updated (in seconds). This effectively throttles invalidations that
 // result from new data arriving for this image.
 constexpr double kFlushDelaySeconds = 1.;
 }  // namespace
 
+class ImageResource::ImageResourceInfoImpl final
+    : public GarbageCollectedFinalized<ImageResourceInfoImpl>,
+      public ImageResourceInfo {
+  USING_GARBAGE_COLLECTED_MIXIN(ImageResourceInfoImpl);
+
+ public:
+  ImageResourceInfoImpl(ImageResource* resource) : m_resource(resource) {
+    DCHECK(m_resource);
+  }
+  DEFINE_INLINE_VIRTUAL_TRACE() {
+    visitor->trace(m_resource);
+    ImageResourceInfo::trace(visitor);
+  }
+
+ private:
+  const KURL& url() const override { return m_resource->url(); }
+  bool isSchedulingReload() const override {
+    return m_resource->m_isSchedulingReload;
+  }
+  bool hasDevicePixelRatioHeaderValue() const override {
+    return m_resource->m_hasDevicePixelRatioHeaderValue;
+  }
+  float devicePixelRatioHeaderValue() const override {
+    return m_resource->m_devicePixelRatioHeaderValue;
+  }
+  const ResourceResponse& response() const override {
+    return m_resource->response();
+  }
+  Resource::Status getStatus() const override {
+    return m_resource->getStatus();
+  }
+  bool isPlaceholder() const override { return m_resource->isPlaceholder(); }
+  bool isCacheValidator() const override {
+    return m_resource->isCacheValidator();
+  }
+  bool schedulingReloadOrShouldReloadBrokenPlaceholder() const override {
+    return m_resource->m_isSchedulingReload ||
+           m_resource->shouldReloadBrokenPlaceholder();
+  }
+  bool isAccessAllowed(
+      SecurityOrigin* securityOrigin,
+      DoesCurrentFrameHaveSingleSecurityOrigin
+          doesCurrentFrameHasSingleSecurityOrigin) const override {
+    return m_resource->isAccessAllowed(securityOrigin,
+                                       doesCurrentFrameHasSingleSecurityOrigin);
+  }
+  bool hasCacheControlNoStoreHeader() const override {
+    return m_resource->hasCacheControlNoStoreHeader();
+  }
+  const ResourceError& resourceError() const override {
+    return m_resource->resourceError();
+  }
+
+  void decodeError(bool allDataReceived) override {
+    m_resource->decodeError(allDataReceived);
+  }
+  void setDecodedSize(size_t size) override {
+    m_resource->setDecodedSize(size);
+  }
+  void willAddClientOrObserver() override {
+    m_resource->willAddClientOrObserver(Resource::MarkAsReferenced);
+  }
+  void didRemoveClientOrObserver() override {
+    m_resource->didRemoveClientOrObserver();
+  }
+  void emulateLoadStartedForInspector(
+      ResourceFetcher* fetcher,
+      const KURL& url,
+      const AtomicString& initiatorName) override {
+    fetcher->emulateLoadStartedForInspector(m_resource.get(), url,
+                                            WebURLRequest::RequestContextImage,
+                                            initiatorName);
+  }
+
+  const Member<ImageResource> m_resource;
+};
+
 class ImageResource::ImageResourceFactory : public ResourceFactory {
   STACK_ALLOCATED();
 
  public:
   ImageResourceFactory(const FetchRequest& fetchRequest)
       : ResourceFactory(Resource::Image), m_fetchRequest(&fetchRequest) {}
 
   Resource* create(const ResourceRequest& request,
                    const ResourceLoaderOptions& options,
                    const String&) const override {
-    return new ImageResource(request, options,
+    return new ImageResource(request, options, ImageResourceContent::create(),
                              m_fetchRequest->placeholderImageRequestType() ==
                                  FetchRequest::AllowPlaceholder);
   }
 
  private:
   // Weak, unowned pointer. Must outlive |this|.
   const FetchRequest* m_fetchRequest;
 };
 
 ImageResource* ImageResource::fetch(FetchRequest& request,
@@ skipping 23 matching lines @@
       resource->m_isPlaceholder) {
     // If the image is a placeholder, but this fetch doesn't allow a
     // placeholder, then load the original image. Note that the cache is not
     // bypassed here - it should be fine to use a cached copy if possible.
     resource->reloadIfLoFiOrPlaceholder(fetcher,
                                         ReloadCachePolicy::UseExistingPolicy);
   }
   return resource;
 }
 
+ImageResource* ImageResource::create(const ResourceRequest& request) {
+  return new ImageResource(request, ResourceLoaderOptions(),
+                           ImageResourceContent::create(), false);
+}
+
 ImageResource::ImageResource(const ResourceRequest& resourceRequest,
                              const ResourceLoaderOptions& options,
+                             ImageResourceContent* content,
                              bool isPlaceholder)
     : Resource(resourceRequest, Image, options),
+      m_content(content),
       m_devicePixelRatioHeaderValue(1.0),
-      m_image(nullptr),
       m_hasDevicePixelRatioHeaderValue(false),
       m_isSchedulingReload(false),
       m_isPlaceholder(isPlaceholder),
-      m_flushTimer(this, &ImageResource::flushImageIfNeeded),
-      m_isRefetchableDataFromDiskCache(true) {
+      m_flushTimer(this, &ImageResource::flushImageIfNeeded) {
+  DCHECK(getContent());
   RESOURCE_LOADING_DVLOG(1) << "new ImageResource(ResourceRequest) " << this;
-}
-
-ImageResource::ImageResource(blink::Image* image,
-                             const ResourceLoaderOptions& options)
-    : Resource(ResourceRequest(""), Image, options),
-      m_devicePixelRatioHeaderValue(1.0),
-      m_image(image),
-      m_hasDevicePixelRatioHeaderValue(false),
-      m_isSchedulingReload(false),
-      m_isPlaceholder(false),
-      m_flushTimer(this, &ImageResource::flushImageIfNeeded),
-      m_isRefetchableDataFromDiskCache(true) {
-  RESOURCE_LOADING_DVLOG(1) << "new ImageResource(Image) " << this;
-  setStatus(Cached);
+  getContent()->setImageResourceInfo(new ImageResourceInfoImpl(this));
 }
 
 ImageResource::~ImageResource() {
   RESOURCE_LOADING_DVLOG(1) << "~ImageResource " << this;
-  clearImage();
 }
 
 DEFINE_TRACE(ImageResource) {
   visitor->trace(m_multipartParser);
+  visitor->trace(m_content);
   Resource::trace(visitor);
-  ImageObserver::trace(visitor);
   MultipartImageResourceParser::Client::trace(visitor);
 }
 
 void ImageResource::checkNotify() {
   // Don't notify clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
   Resource::checkNotify();
 }
 
-void ImageResource::markObserverFinished(ImageResourceObserver* observer) {
-  auto it = m_observers.find(observer);
-  if (it == m_observers.end())
-    return;
-  m_observers.remove(it);
-  m_finishedObservers.add(observer);
+bool ImageResource::hasClientsOrObservers() const {
+  return Resource::hasClientsOrObservers() || getContent()->hasObservers();
 }
 
 void ImageResource::didAddClient(ResourceClient* client) {
-  DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
+  DCHECK((m_multipartParser && isLoading()) || !data() ||
+         getContent()->hasImage());
 
   // Don't notify observers and clients of completion if this ImageResource is
   // about to be reloaded.
   if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
     return;
 
   Resource::didAddClient(client);
 }
 
-void ImageResource::addObserver(ImageResourceObserver* observer) {
-  willAddClientOrObserver(MarkAsReferenced);
-
-  m_observers.add(observer);
-
-  if (isCacheValidator())
-    return;
-
-  // When the response is not multipart, if |data()| exists, |m_image| must be
-  // created. This is assured that |updateImage()| is called when |appendData()|
-  // is called.
-  //
-  // On the other hand, when the response is multipart, |updateImage()| is not
-  // called in |appendData()|, which means |m_image| might not be created even
-  // when |data()| exists. This is intentional since creating a |m_image| on
-  // receiving data might destroy an existing image in a previous part.
-  DCHECK((m_multipartParser && isLoading()) || !data() || m_image);
-
-  if (m_image && !m_image->isNull()) {
-    observer->imageChanged(this);
-  }
-
-  if (isLoaded() && m_observers.contains(observer) && !m_isSchedulingReload &&
-      !shouldReloadBrokenPlaceholder()) {
-    markObserverFinished(observer);
-    observer->imageNotifyFinished(this);
-  }
-}
-
-void ImageResource::removeObserver(ImageResourceObserver* observer) {
-  DCHECK(observer);
-
-  auto it = m_observers.find(observer);
-  if (it != m_observers.end()) {
-    m_observers.remove(it);
-  } else {
-    it = m_finishedObservers.find(observer);
-    DCHECK(it != m_finishedObservers.end());
-    m_finishedObservers.remove(it);
-  }
-  didRemoveClientOrObserver();
-}
-
-static void priorityFromObserver(const ImageResourceObserver* observer,
-                                 ResourcePriority& priority) {
-  ResourcePriority nextPriority = observer->computeResourcePriority();
-  if (nextPriority.visibility == ResourcePriority::NotVisible)
-    return;
-  priority.visibility = ResourcePriority::Visible;
-  priority.intraPriorityValue += nextPriority.intraPriorityValue;
-}
-
-ResourcePriority ImageResource::priorityFromObservers() {
-  ResourcePriority priority;
-
-  for (const auto& it : m_finishedObservers)
-    priorityFromObserver(it.key, priority);
-  for (const auto& it : m_observers)
-    priorityFromObserver(it.key, priority);
-
-  return priority;
-}
-
 void ImageResource::destroyDecodedDataForFailedRevalidation() {
-  clearImage();
+  getContent()->clearImage();
   setDecodedSize(0);
 }
 
 void ImageResource::destroyDecodedDataIfPossible() {
-  if (!m_image)
-    return;
-  CHECK(!errorOccurred());
-  m_image->destroyDecodedData();
-  if (!isPreloaded() && m_isRefetchableDataFromDiskCache) {
+  getContent()->destroyDecodedData();
+  if (getContent()->hasImage() && !isPreloaded() &&
+      getContent()->isRefetchableDataFromDiskCache()) {
     UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer.EstimatedDroppableEncodedSize",
                             encodedSize() / 1024);
   }
 }
 
-void ImageResource::doResetAnimation() {
-  if (m_image)
-    m_image->resetAnimation();
-}
-
 void ImageResource::allClientsAndObserversRemoved() {
-  if (m_image) {
-    CHECK(!errorOccurred());
-    // If possible, delay the resetting until back at the event loop. Doing so
-    // after a conservative GC prevents resetAnimation() from upsetting ongoing
-    // animation updates (crbug.com/613709)
-    if (!ThreadHeap::willObjectBeLazilySwept(this)) {
-      Platform::current()->currentThread()->getWebTaskRunner()->postTask(
-          BLINK_FROM_HERE, WTF::bind(&ImageResource::doResetAnimation,
-                                     wrapWeakPersistent(this)));
-    } else {
-      m_image->resetAnimation();
-    }
+  CHECK(!getContent()->hasImage() || !errorOccurred());
+  // If possible, delay the resetting until back at the event loop. Doing so
+  // after a conservative GC prevents resetAnimation() from upsetting ongoing
+  // animation updates (crbug.com/613709)
+  if (!ThreadHeap::willObjectBeLazilySwept(this)) {
+    Platform::current()->currentThread()->getWebTaskRunner()->postTask(
+        BLINK_FROM_HERE, WTF::bind(&ImageResourceContent::doResetAnimation,
+                                   wrapWeakPersistent(getContent())));
+  } else {
+    getContent()->doResetAnimation();
   }
   if (m_multipartParser)
     m_multipartParser->cancel();
   Resource::allClientsAndObserversRemoved();
 }
 
 PassRefPtr<const SharedBuffer> ImageResource::resourceBuffer() const {
   if (data())
     return data();
-  if (m_image)
-    return m_image->data();
+  if (getContent()->hasImage())
+    return getContent()->getImage()->data();
   return nullptr;
 }
 
 void ImageResource::appendData(const char* data, size_t length) {
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(length);
   if (m_multipartParser) {
     m_multipartParser->appendData(data, length);
   } else {
     Resource::appendData(data, length);
 
     // If we don't have the size available yet, then update immediately since
     // we need to know the image size as soon as possible. Likewise for
     // animated images, update right away since we shouldn't throttle animated
     // images.
-    if (m_sizeAvailable == Image::SizeUnavailable ||
-        (m_image && m_image->maybeAnimated())) {
-      updateImage(false);
+    if (!getContent()->isSizeAvailable() ||
+        (getContent()->hasImage() &&
+         getContent()->getImage()->maybeAnimated())) {
+      getContent()->updateImage(this->data(),
+                                ImageResourceContent::KeepExistingImage, false);
       return;
     }
 
     // For other cases, only update at |kFlushDelaySeconds| intervals. This
     // throttles how frequently we update |m_image| and how frequently we
     // inform the clients which causes an invalidation of this image. In other
     // words, we only invalidate this image every |kFlushDelaySeconds| seconds
     // while loading.
     if (!m_flushTimer.isActive()) {
       double now = WTF::monotonicallyIncreasingTime();
       if (!m_lastFlushTime)
         m_lastFlushTime = now;
 
       DCHECK_LE(m_lastFlushTime, now);
       double flushDelay = m_lastFlushTime - now + kFlushDelaySeconds;
       if (flushDelay < 0.)
         flushDelay = 0.;
       m_flushTimer.startOneShot(flushDelay, BLINK_FROM_HERE);
     }
   }
 }
 
 void ImageResource::flushImageIfNeeded(TimerBase*) {
   // We might have already loaded the image fully, in which case we don't need
   // to call |updateImage()|.
   if (isLoading()) {
     m_lastFlushTime = WTF::monotonicallyIncreasingTime();
-    updateImage(false);
+    getContent()->updateImage(this->data(),
+                              ImageResourceContent::KeepExistingImage, false);
   }
 }
 
-std::pair<blink::Image*, float> ImageResource::brokenImage(
-    float deviceScaleFactor) {
-  if (deviceScaleFactor >= 2) {
-    DEFINE_STATIC_REF(blink::Image, brokenImageHiRes,
-                      (blink::Image::loadPlatformResource("missingImage@2x")));
-    return std::make_pair(brokenImageHiRes, 2);
-  }
-
-  DEFINE_STATIC_REF(blink::Image, brokenImageLoRes,
-                    (blink::Image::loadPlatformResource("missingImage")));
-  return std::make_pair(brokenImageLoRes, 1);
-}
-
 bool ImageResource::willPaintBrokenImage() const {
   return errorOccurred();
 }
 
-blink::Image* ImageResource::getImage() {
-  if (errorOccurred()) {
-    // Returning the 1x broken image is non-ideal, but we cannot reliably access
-    // the appropriate deviceScaleFactor from here. It is critical that callers
-    // use ImageResource::brokenImage() when they need the real,
-    // deviceScaleFactor-appropriate broken image icon.
-    return brokenImage(1).first;
+void ImageResource::decodeError(bool allDataReceived) {
+  size_t size = encodedSize();
+
+  clearData();
+  setEncodedSize(0);
+  if (!errorOccurred())
+    setStatus(DecodeError);
+
+  if (!allDataReceived && loader()) {
+    // TODO(hiroshige): Do not call didFinishLoading() directly.
+    loader()->didFinishLoading(monotonicallyIncreasingTime(), size, size);
   }
 
-  if (m_image)
-    return m_image.get();
-
-  return blink::Image::nullImage();
-}
-
-bool ImageResource::usesImageContainerSize() const {
-  if (m_image)
-    return m_image->usesContainerSize();
-
-  return false;
-}
-
-bool ImageResource::imageHasRelativeSize() const {
-  if (m_image)
-    return m_image->hasRelativeSize();
-
-  return false;
-}
-
-LayoutSize ImageResource::imageSize(
-    RespectImageOrientationEnum shouldRespectImageOrientation,
-    float multiplier,
-    SizeType sizeType) {
-  if (!m_image)
-    return LayoutSize();
-
-  LayoutSize size;
-
-  if (m_image->isBitmapImage() &&
-      shouldRespectImageOrientation == RespectImageOrientation) {
-    size =
-        LayoutSize(toBitmapImage(m_image.get())->sizeRespectingOrientation());
-  } else {
-    size = LayoutSize(m_image->size());
-  }
-
-  if (sizeType == IntrinsicCorrectedToDPR && m_hasDevicePixelRatioHeaderValue &&
-      m_devicePixelRatioHeaderValue > 0)
-    multiplier = 1 / m_devicePixelRatioHeaderValue;
-
-  if (multiplier == 1 || m_image->hasRelativeSize())
-    return size;
-
-  // Don't let images that have a width/height >= 1 shrink below 1 when zoomed.
-  LayoutSize minimumSize(
-      size.width() > LayoutUnit() ? LayoutUnit(1) : LayoutUnit(),
-      LayoutUnit(size.height() > LayoutUnit() ? LayoutUnit(1) : LayoutUnit()));
-  size.scale(multiplier);
-  size.clampToMinimumSize(minimumSize);
-  return size;
-}
-
-void ImageResource::notifyObservers(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_isSchedulingReload &&
-          !shouldReloadBrokenPlaceholder()) {
-        markObserverFinished(observer);
-        observer->imageNotifyFinished(this);
-      }
-    }
-  }
-}
-
-void ImageResource::clear() {
-  clearImage();
-  clearData();
-  setEncodedSize(0);
-}
-
-inline void ImageResource::createImage() {
-  // Create the image if it doesn't yet exist.
-  if (m_image)
-    return;
-
-  if (response().mimeType() == "image/svg+xml") {
-    m_image = SVGImage::create(this);
-  } else {
-    m_image = BitmapImage::create(this);
-  }
-}
-
-inline void ImageResource::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 ImageResource::updateImage(bool allDataReceived) {
-  TRACE_EVENT0("blink", "ImageResource::updateImage");
-
-  if (data())
-    createImage();
-
-  // 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()) {
-    DCHECK(m_image);
-    m_sizeAvailable = m_image->setData(data(), allDataReceived);
-  }
-
-  // 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 (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived)
-    return;
-
-  if (m_isPlaceholder && allDataReceived && m_image && !m_image->isNull()) {
-    if (m_sizeAvailable == Image::SizeAvailable) {
-      // TODO(sclittle): Show the original image if the response consists of the
-      // entire image, such as if the entire image response body is smaller than
-      // the requested range.
-      IntSize dimensions = m_image->size();
-      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_image || m_image->isNull()) {
-    size_t size = encodedSize();
-    clear();
-    if (!errorOccurred())
-      setStatus(DecodeError);
-    if (!allDataReceived && loader()) {
-      loader()->didFinishLoading(monotonicallyIncreasingTime(), size, size);
-    }
-    memoryCache()->remove(this);
-  }
-
-  // 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);
+  memoryCache()->remove(this);
 }
 
 void ImageResource::updateImageAndClearBuffer() {
-  clearImage();
-  updateImage(true);
+  getContent()->updateImage(data(), ImageResourceContent::ClearExistingImage,
+                            true);
   clearData();
 }
 
 void ImageResource::finish(double loadFinishTime) {
   if (m_multipartParser) {
     m_multipartParser->finish();
     if (data())
       updateImageAndClearBuffer();
   } else {
-    updateImage(true);
+    getContent()->updateImage(data(), ImageResourceContent::KeepExistingImage,
+                              true);
     // As encoded image data can be created from m_image  (see
     // ImageResource::resourceBuffer(), we don't have to keep m_data. Let's
     // clear this. As for the lifetimes of m_image and m_data, see this
     // document:
     // https://docs.google.com/document/d/1v0yTAZ6wkqX2U_M6BNIGUJpM1s0TIw1VsqpxoL7aciY/edit?usp=sharing
     clearData();
   }
   Resource::finish(loadFinishTime);
 }
 
 void ImageResource::error(const ResourceError& error) {
   if (m_multipartParser)
     m_multipartParser->cancel();
-  clear();
+  // TODO(hiroshige): Move setEncodedSize() call to Resource::error() if it
+  // is really needed, or remove it otherwise.
+  setEncodedSize(0);
   Resource::error(error);
-  notifyObservers(ShouldNotifyFinish);
+  getContent()->clearImageAndNotifyObservers(
+      ImageResourceContent::ShouldNotifyFinish);
 }
 
 void ImageResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!handle);
   DCHECK(!m_multipartParser);
   // If there's no boundary, just handle the request normally.
   if (response.isMultipart() && !response.multipartBoundary().isEmpty()) {
     m_multipartParser = new MultipartImageResourceParser(
         response, response.multipartBoundary(), this);
   }
   Resource::responseReceived(response, std::move(handle));
   if (RuntimeEnabledFeatures::clientHintsEnabled()) {
     m_devicePixelRatioHeaderValue =
         this->response()
             .httpHeaderField(HTTPNames::Content_DPR)
             .toFloat(&m_hasDevicePixelRatioHeaderValue);
     if (!m_hasDevicePixelRatioHeaderValue ||
         m_devicePixelRatioHeaderValue <= 0.0) {
       m_devicePixelRatioHeaderValue = 1.0;
       m_hasDevicePixelRatioHeaderValue = false;
     }
   }
 }
 
-void ImageResource::decodedSizeChangedTo(const blink::Image* image,
-                                         size_t newSize) {
-  if (!image || image != m_image)
-    return;
-
-  setDecodedSize(newSize);
-}
-
-bool ImageResource::shouldPauseAnimation(const blink::Image* image) {
-  if (!image || image != m_image)
-    return false;
-
-  for (const auto& it : m_finishedObservers)
-    if (it.key->willRenderImage())
-      return false;
-
-  for (const auto& it : m_observers)
-    if (it.key->willRenderImage())
-      return false;
-
-  return true;
-}
-
-void ImageResource::animationAdvanced(const blink::Image* image) {
-  if (!image || image != m_image)
-    return;
-  notifyObservers(DoNotNotifyFinish);
-}
-
-void ImageResource::updateImageAnimationPolicy() {
-  if (!m_image)
-    return;
-
-  ImageAnimationPolicy newPolicy = ImageAnimationPolicyAllowed;
-  for (const auto& it : m_finishedObservers) {
-    if (it.key->getImageAnimationPolicy(newPolicy))
-      break;
-  }
-  for (const auto& it : m_observers) {
-    if (it.key->getImageAnimationPolicy(newPolicy))
-      break;
-  }
-
-  if (m_image->animationPolicy() != newPolicy) {
-    m_image->resetAnimation();
-    m_image->setAnimationPolicy(newPolicy);
-  }
-}
-
 static bool isLoFiImage(const ImageResource& resource) {
   if (resource.resourceRequest().loFiState() != WebURLRequest::LoFiOn)
     return false;
   return !resource.isLoaded() ||
          resource.response()
              .httpHeaderField("chrome-proxy-content-transform")
              .contains("empty-image");
 }
 
 void ImageResource::reloadIfLoFiOrPlaceholder(
@@ skipping 17 matching lines @@
     m_isPlaceholder = false;
     clearRangeRequestHeader();
   }
 
   if (isLoading()) {
     loader()->cancel();
     // Canceling the loader causes error() to be called, which in turn calls
     // clear() and notifyObservers(), so there's no need to call these again
     // here.
   } else {
-    clear();
-    notifyObservers(DoNotNotifyFinish);
+    clearData();
+    setEncodedSize(0);
+    getContent()->clearImageAndNotifyObservers(
+        ImageResourceContent::DoNotNotifyFinish);
   }
 
   setStatus(NotStarted);
 
   DCHECK(m_isSchedulingReload);
   m_isSchedulingReload = false;
 
   fetcher->startLoad(this);
 }
 
-void ImageResource::changedInRect(const blink::Image* image,
-                                  const IntRect& rect) {
-  if (!image || image != m_image)
-    return;
-  notifyObservers(DoNotNotifyFinish, &rect);
-}
-
 void ImageResource::onePartInMultipartReceived(
     const ResourceResponse& response) {
   DCHECK(m_multipartParser);
 
   setResponse(response);
   if (m_multipartParsingState == MultipartParsingState::WaitingForFirstPart) {
     // We have nothing to do because we don't have any data.
     m_multipartParsingState = MultipartParsingState::ParsingFirstPart;
     return;
   }
@@ skipping 11 matching lines @@
     if (loader())
       loader()->didFinishLoadingFirstPartInMultipart();
   }
 }
 
 void ImageResource::multipartDataReceived(const char* bytes, size_t size) {
   DCHECK(m_multipartParser);
   Resource::appendData(bytes, size);
 }
 
-bool ImageResource::isAccessAllowed(SecurityOrigin* securityOrigin) {
+bool ImageResource::isAccessAllowed(
+    SecurityOrigin* securityOrigin,
+    ImageResourceInfo::DoesCurrentFrameHaveSingleSecurityOrigin
+        doesCurrentFrameHasSingleSecurityOrigin) const {
   if (response().wasFetchedViaServiceWorker()) {
     return response().serviceWorkerResponseType() !=
            WebServiceWorkerResponseTypeOpaque;
   }
-  if (!getImage()->currentFrameHasSingleSecurityOrigin())
+  if (doesCurrentFrameHasSingleSecurityOrigin !=
+      ImageResourceInfo::HasSingleSecurityOrigin)
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
+ImageResourceContent* ImageResource::getContent() const {
+  return m_content;
+}
+
+ResourcePriority ImageResource::priorityFromObservers() {
+  return getContent()->priorityFromObservers();
+}
+
 }  // namespace blink