[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 21 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) {
-  if (m_observers.contains(observer)) {
-    m_finishedObservers.add(observer);
-    m_observers.remove(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);
-
-  if (m_observers.contains(observer))
-    m_observers.remove(observer);
-  else if (m_finishedObservers.contains(observer))
-    m_finishedObservers.remove(observer);
-  else
-    NOTREACHED();
-
-  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 (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer))
-      priorityFromObserver(observer, priority);
-  }
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer))
-      priorityFromObserver(observer, 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() ||

[Nate Chapin, 2016/12/07 20:27:28]

Should this if() block be a helper ImageResourceContent instead?

[hiroshige, 2016/12/09 22:50:39]

I'd like to call updateImage() directly here, rather than moving this whole
block into ImageResourceContent, in order to
- Make updateImage() a single point of modification of ImageResourceContent
(directed by ImageResource) as much as possible, and
- Keep the mental model that "ImageResource just throttles the call of
updateImage() in Lines 283--322" and thus keep the control logic in
ImageResource.

Alternatively, I also thought if we can move the whole of throttling mechanism
into ImageResourceContent (i.e. Move the most of Lines 283--322 as well as the
timer). However, it requires references to Resource::m_data from
ImageResourceContent if we delay updateImage() until flushImageIfNeeded(), which
is not clean.

I expect we might be able to move the throttling logic to ImageResource when we
further decouples ImageResource and ImageResourceContent in the future (probably
it will be after we remove EventSenders in ImageLoader).

[hiroshige, 2016/12/11 19:17:01]

I moved only the |if| conditional expression to ImageResourceContent,
- to partially handle this japhet@'s comment, and
- to remove getImage() call from ImageResource that was (and should be)
|m_image|.

+        (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 (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer) && observer->willRenderImage())
-      return false;
-  }
-
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer) && observer->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 (auto* observer : m_finishedObservers.asVector()) {
-    if (m_finishedObservers.contains(observer) &&
-        observer->getImageAnimationPolicy(newPolicy))
-      break;
-  }
-  for (auto* observer : m_observers.asVector()) {
-    if (m_observers.contains(observer) &&
-        observer->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