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 27 matching lines @@
 #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 {
 
+// 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.
+static double flushDelaySeconds = 1.;

[pdr., 2016/10/05 02:07:31]

Should we use constexpr and a k prefix here?
E.g., "constexpr double kFlushDelaySeconds = 1.;"?

+
 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() &&
         fetcher->context().canRequest(Resource::Image,
@@ skipping 177 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 |flushDelaySeconds| intervals.

[pdr., 2016/10/05 02:07:31]

Can you expand on this comment a bit? Similar to your comment above
flushDelaySeconds, I'd like to make it clear that we're throttling the
updateImage call to reduce invalidations.

+    double now = WTF::currentTime();
+    if (m_lastFlushTime && (m_lastFlushTime + flushDelaySeconds <= 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