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

third_party/WebKit/Source/core/loader/resource/ImageResourceContent.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/loader/resource/ImageResourceContent.h"
 
 #include "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ImageResourceInfo.h"
 #include "core/loader/resource/ImageResourceObserver.h"
 #include "core/svg/graphics/SVGImage.h"
@@ skipping 280 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 parseContentRangeHeaderFor206(
+             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 ImageResourceContent::updateImage(PassRefPtr<SharedBuffer> data,
                                        UpdateImageOption updateImageOption,
                                        bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
   // Clears the existing image, if instructed by |updateImageOption|.
   switch (updateImageOption) {
     case ClearAndUpdateImage:
     case ClearImageAndNotifyObservers:
       clearImage();
@@ skipping 19 matching lines @@
         DCHECK(m_image);
         m_sizeAvailable = m_image->setData(std::move(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_info->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_info->isPlaceholder() && allDataReceived) {
+        if (shouldShowFullImageInsteadOfPlaceholder(response(),
+                                                    m_image.get())) {
+          m_info->setIsPlaceholder(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()) {
         clearImage();
         m_info->decodeError(allDataReceived);
       }
       break;
   }
 
   // Notifies the observers.
   // 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.
@@ skipping 113 matching lines @@
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
 
 }  // namespace blink