Blink: Throttle progressively loaded images.

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
@@ skipping 28 matching lines @@
 #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::ImageResourceFactory : public ResourceFactory {
   STACK_ALLOCATED();
 
  public:
   ImageResourceFactory(const FetchRequest& fetchRequest)
       : ResourceFactory(Resource::Image), m_fetchRequest(&fetchRequest) {}
 
   Resource* create(const ResourceRequest& request,
                    const ResourceLoaderOptions& options,
@@ skipping 41 matching lines @@
 }
 
 ImageResource::ImageResource(const ResourceRequest& resourceRequest,
                              const ResourceLoaderOptions& options,
                              bool isPlaceholder)
     : Resource(resourceRequest, Image, options),
       m_devicePixelRatioHeaderValue(1.0),
       m_image(nullptr),
       m_hasDevicePixelRatioHeaderValue(false),
       m_isSchedulingReload(false),
-      m_isPlaceholder(isPlaceholder) {
+      m_isPlaceholder(isPlaceholder),
+      m_flushTimer(this, &ImageResource::flushImageIfNeeded) {
   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_isPlaceholder(false),
+      m_flushTimer(this, &ImageResource::flushImageIfNeeded) {
   RESOURCE_LOADING_DVLOG(1) << "new ImageResource(Image) " << this;
   setStatus(Cached);
 }
 
 ImageResource::~ImageResource() {
   RESOURCE_LOADING_DVLOG(1) << "~ImageResource " << this;
   clearImage();
 }
 
 DEFINE_TRACE(ImageResource) {
@@ skipping 153 matching lines @@
     return m_image->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);
+      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);
   }
 }
 
 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);
@@ skipping 102 matching lines @@
 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();
 
-  Image::SizeAvailability sizeAvailable = Image::SizeUnavailable;
-
   // 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);
-    sizeAvailable = m_image->setData(data(), allDataReceived);
+    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 (sizeAvailable == Image::SizeUnavailable && !allDataReceived)
+  if (m_sizeAvailable == Image::SizeUnavailable && !allDataReceived)
     return;
 
   if (m_isPlaceholder && allDataReceived && m_image && !m_image->isNull()) {
-    if (sizeAvailable == Image::SizeAvailable) {
+    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();
@@ skipping 226 matching lines @@
            WebServiceWorkerResponseTypeOpaque;
   }
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink