Phase II Step 2: Remove setIsPlaceholder() in updateImage()

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 <memory>
 
 #include "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ImageResourceInfo.h"
@@ skipping 22 matching lines @@
 
   DEFINE_INLINE_VIRTUAL_TRACE() { ImageResourceInfo::trace(visitor); }
 
  private:
   const KURL& url() const override { return m_url; }
   bool isSchedulingReload() const override { return false; }
   bool hasDevicePixelRatioHeaderValue() const override { return false; }
   float devicePixelRatioHeaderValue() const override { return 1.0; }
   const ResourceResponse& response() const override { return m_response; }
   ResourceStatus getStatus() const override { return ResourceStatus::Cached; }
-  bool isPlaceholder() const override { return false; }
+  bool shouldShowPlaceholder() const override { return false; }
   bool isCacheValidator() const override { return false; }
   bool schedulingReloadOrShouldReloadBrokenPlaceholder() const override {
     return false;
   }
   bool isAccessAllowed(
       SecurityOrigin*,
       DoesCurrentFrameHaveSingleSecurityOrigin) const override {
     return true;
   }
   bool hasCacheControlNoStoreHeader() const override { return false; }
   const ResourceError& resourceError() const override { return m_error; }
 
   void setDecodedSize(size_t) override {}
-  void setIsPlaceholder(bool) override {}
   void willAddClientOrObserver() override {}
   void didRemoveClientOrObserver() override {}
   void emulateLoadStartedForInspector(
       ResourceFetcher*,
       const KURL&,
       const AtomicString& initiatorName) override {}
 
   const KURL m_url;
   const ResourceResponse m_response;
   const ResourceError m_error;
@@ skipping 223 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;
-}
-
 ImageResourceContent::UpdateImageResult ImageResourceContent::updateImage(
     PassRefPtr<SharedBuffer> data,
     UpdateImageOption updateImageOption,
     bool allDataReceived) {
   TRACE_EVENT0("blink", "ImageResourceContent::updateImage");
 
 #if DCHECK_IS_ON()
   DCHECK(!m_isUpdateImageBeingCalled);
   AutoReset<bool> scope(&m_isUpdateImageBeingCalled, true);
 #endif
@@ skipping 25 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 UpdateImageResult::NoDecodeError;
 
-      if (m_info->isPlaceholder() && allDataReceived) {
-        if (shouldShowFullImageInsteadOfPlaceholder(response(),
-                                                    m_image.get())) {
-          m_info->setIsPlaceholder(false);
-        } else if (m_image && !m_image->isNull()) {
+      if (m_info->shouldShowPlaceholder() && allDataReceived) {
+        if (m_image && !m_image->isNull()) {
           IntSize dimensions = m_image->size();
           clearImage();
           m_image = PlaceholderImage::create(this, dimensions);
         }
       }
 
       if (!m_image || m_image->isNull()) {
         clearImage();
         return UpdateImageResult::ShouldDecodeError;
       }
@@ skipping 120 matching lines @@
 
 const ResourceResponse& ImageResourceContent::response() const {
   return m_info->response();
 }
 
 const ResourceError& ImageResourceContent::resourceError() const {
   return m_info->resourceError();
 }
 
 }  // namespace blink