Don't show a placeholder if the response contains the full image.

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 18 matching lines @@
 #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/network/HTTPParsers.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 <stdint.h>
 #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
 
@@ skipping 397 matching lines @@
   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;
 }
 
+// Determines if |response| likely contains the entire resource for the purposes
+// of determining whether or not to show a placeholder, e.g. if the server
+// responded with a full 200 response or if the full image is smaller than the
+// requested range.
+static bool isEntireResource(const ResourceResponse& response) {
+  if (response.httpStatusCode() != 206)
+    return true;
+
+  int64_t firstBytePosition = -1, lastBytePosition = -1, instanceLength = -1;
+  return parseContentRangeHeader(response.httpHeaderField("Content-Range"),
+                                 &firstBytePosition, &lastBytePosition,
+                                 &instanceLength) &&
+         firstBytePosition == 0 && lastBytePosition + 1 == instanceLength;
+}
+
+static bool shouldShowFullImageInsteadOfPlaceholder(
+    const ResourceResponse& response,
+    const Image* image) {
+  if (!isEntireResource(response))
+    return false;
+  if (image && !image->isNull())
+    return true;
+
+  // Don't treat a complete and broken image as a placeholder if the response
+  // code is something other than a 4xx or 5xx error. This is done to prevent
+  // reissuing the request in cases like "204 No Content" responses to tracking
+  // requests triggered by <img> tags, and <img> tags used to preload non-image
+  // resources.
+  return response.httpStatusCode() < 400 || response.httpStatusCode() >= 600;
+}
+
 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.
+  if (m_isPlaceholder && allDataReceived) {
+    if (shouldShowFullImageInsteadOfPlaceholder(response(), m_image.get())) {
+      m_isPlaceholder = false;
+    } else if (m_image && !m_image->isNull()) {
       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);
@@ skipping 207 matching lines @@
            WebServiceWorkerResponseTypeOpaque;
   }
   if (!getImage()->currentFrameHasSingleSecurityOrigin())
     return false;
   if (passesAccessControlCheck(securityOrigin))
     return true;
   return !securityOrigin->taintsCanvas(response().url());
 }
 
 }  // namespace blink