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 26 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
 
 ImageResource* ImageResource::fetch(FetchRequest& request,
                                     ResourceFetcher* fetcher) {
   if (request.resourceRequest().requestContext() ==
       WebURLRequest::RequestContextUnspecified)
     request.mutableResourceRequest().setRequestContext(
         WebURLRequest::RequestContextImage);
   if (fetcher->context().pageDismissalEventBeingDispatched()) {
     KURL requestURL = request.resourceRequest().url();
     if (requestURL.isValid() &&
@@ skipping 72 matching lines @@
 }
 
 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.
+  // When the response is not multipart, if |data()| exists and image is loaded,
+  // |m_image| must be created. This is assured that |updateImage()| is called
+  // when the image finishes loading. However, while loading |appendData()| can
+  // throttle |updateImage()| calls.
   //
   // 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);
+  DCHECK((m_multipartParser && isLoading()) || !data() || m_image ||
+         !isLoaded());
 
   if (m_image && !m_image->isNull()) {
     observer->imageChanged(this);
   }
 
   if (isLoaded()) {
     markObserverFinished(observer);
     observer->imageNotifyFinished(this);
   }
 }
@@ skipping 77 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);
-    updateImage(false);
+
+    // If we have an animated image, then update as soon as we have more data.
+    if (m_image && m_image->maybeAnimated()) {
+      updateImage(false);
+      return;
+    }
+
+    // For other images, 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.
+    double now = WTF::currentTime();
+    if (!m_lastFlushTime) {
+      m_lastFlushTime = now;
+    } else if (m_lastFlushTime + kFlushDelaySeconds <= now) {
+      updateImage(false);
+      m_lastFlushTime = now;
+    }
   }
 }
 
 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 330 matching lines @@
     return response().serviceWorkerResponseType() !=
            WebServiceWorkerResponseTypeOpaque;
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink