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

third_party/WebKit/Source/core/loader/resource/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
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "core/loader/resource/ImageResource.h"
 
+#include <stdint.h>
+#include <v8.h>
 #include <memory>
 
 #include "core/loader/resource/ImageResourceContent.h"
 #include "core/loader/resource/ImageResourceInfo.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceClient.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceLoader.h"
 #include "platform/loader/fetch/ResourceLoadingLog.h"
+#include "platform/network/HTTPParsers.h"
 #include "platform/weborigin/SecurityViolationReportingPolicy.h"
 #include "public/platform/Platform.h"
 #include "v8/include/v8.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/StdLibExtras.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
@@ skipping 23 matching lines @@
   bool hasDevicePixelRatioHeaderValue() const override {
     return m_resource->m_hasDevicePixelRatioHeaderValue;
   }
   float devicePixelRatioHeaderValue() const override {
     return m_resource->m_devicePixelRatioHeaderValue;
   }
   const ResourceResponse& response() const override {
     return m_resource->response();
   }
   ResourceStatus getStatus() const override { return m_resource->getStatus(); }
-  bool isPlaceholder() const override { return m_resource->isPlaceholder(); }
+  bool shouldShowPlaceholder() const override {
+    return m_resource->shouldShowPlaceholder();
+  }
   bool isCacheValidator() const override {
     return m_resource->isCacheValidator();
   }
   bool schedulingReloadOrShouldReloadBrokenPlaceholder() const override {
     return m_resource->m_isSchedulingReload ||
            m_resource->shouldReloadBrokenPlaceholder();
   }
   bool isAccessAllowed(
       SecurityOrigin* securityOrigin,
       DoesCurrentFrameHaveSingleSecurityOrigin
           doesCurrentFrameHasSingleSecurityOrigin) const override {
     return m_resource->isAccessAllowed(securityOrigin,
                                        doesCurrentFrameHasSingleSecurityOrigin);
   }
   bool hasCacheControlNoStoreHeader() const override {
     return m_resource->hasCacheControlNoStoreHeader();
   }
   const ResourceError& resourceError() const override {
     return m_resource->resourceError();
   }
 
-  void setIsPlaceholder(bool isPlaceholder) override {
-    m_resource->m_isPlaceholder = isPlaceholder;
-  }
   void setDecodedSize(size_t size) override {
     m_resource->setDecodedSize(size);
   }
   void willAddClientOrObserver() override {
     m_resource->willAddClientOrObserver(Resource::MarkAsReferenced);
   }
   void didRemoveClientOrObserver() override {
     m_resource->didRemoveClientOrObserver();
   }
   void emulateLoadStartedForInspector(
@@ skipping 49 matching lines @@
       if (blockReason == ResourceRequestBlockedReason::None)
         fetcher->context().sendImagePing(requestURL);
     }
     return nullptr;
   }
 
   ImageResource* resource = toImageResource(
       fetcher->requestResource(request, ImageResourceFactory(request)));
   if (resource &&
       request.placeholderImageRequestType() != FetchRequest::AllowPlaceholder &&
-      resource->m_isPlaceholder) {
+      resource->shouldShowPlaceholder()) {
     // If the image is a placeholder, but this fetch doesn't allow a
     // placeholder, then load the original image. Note that the cache is not
     // bypassed here - it should be fine to use a cached copy if possible.
     resource->reloadIfLoFiOrPlaceholderImage(
         fetcher, kReloadAlwaysWithExistingCachePolicy);
   }
   return resource;
 }
 
 ImageResource* ImageResource::create(const ResourceRequest& request) {
   return new ImageResource(request, ResourceLoaderOptions(),
                            ImageResourceContent::create(), false);
 }
 
 ImageResource::ImageResource(const ResourceRequest& resourceRequest,
                              const ResourceLoaderOptions& options,
                              ImageResourceContent* content,
                              bool isPlaceholder)
     : Resource(resourceRequest, Image, options),
       m_content(content),
       m_devicePixelRatioHeaderValue(1.0),
       m_hasDevicePixelRatioHeaderValue(false),
       m_isSchedulingReload(false),
-      m_isPlaceholder(isPlaceholder),
+      m_placeholderOption(
+          isPlaceholder ? PlaceholderOption::ShowAndReloadPlaceholderAlways
+                        : PlaceholderOption::DoNotReloadPlaceholder),
       m_flushTimer(this, &ImageResource::flushImageIfNeeded) {
   DCHECK(getContent());
   RESOURCE_LOADING_DVLOG(1) << "new ImageResource(ResourceRequest) " << this;
   getContent()->setImageResourceInfo(new ImageResourceInfoImpl(this));
 }
 
 ImageResource::~ImageResource() {
   RESOURCE_LOADING_DVLOG(1) << "~ImageResource " << this;
 }
 
@@ skipping 102 matching lines @@
 
 void ImageResource::flushImageIfNeeded(TimerBase*) {
   // We might have already loaded the image fully, in which case we don't need
   // to call |updateImage()|.
   if (isLoading()) {
     m_lastFlushTime = WTF::monotonicallyIncreasingTime();
     updateImage(this->data(), ImageResourceContent::UpdateImage, false);
   }
 }
 
-bool ImageResource::willPaintBrokenImage() const {
-  return errorOccurred();
-}
-
 void ImageResource::decodeError(bool allDataReceived) {
   size_t size = encodedSize();
 
   clearData();
   setEncodedSize(0);
   if (!errorOccurred())
     setStatus(ResourceStatus::DecodeError);
 
   // Finishes loading if needed, and notifies observers.
   if (!allDataReceived && loader()) {
@@ skipping 36 matching lines @@
   if (m_multipartParser)
     m_multipartParser->cancel();
   // TODO(hiroshige): Move setEncodedSize() call to Resource::error() if it
   // is really needed, or remove it otherwise.
   setEncodedSize(0);
   Resource::error(error);
   updateImage(nullptr, ImageResourceContent::ClearImageAndNotifyObservers,
               true);
 }
 
+// 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;
+}
+
 void ImageResource::responseReceived(
     const ResourceResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!handle);
   DCHECK(!m_multipartParser);
   // If there's no boundary, just handle the request normally.
   if (response.isMultipart() && !response.multipartBoundary().isEmpty()) {
     m_multipartParser = new MultipartImageResourceParser(
         response, response.multipartBoundary(), this);
   }
   Resource::responseReceived(response, std::move(handle));
   if (RuntimeEnabledFeatures::clientHintsEnabled()) {
     m_devicePixelRatioHeaderValue =
         this->response()
             .httpHeaderField(HTTPNames::Content_DPR)
             .toFloat(&m_hasDevicePixelRatioHeaderValue);
     if (!m_hasDevicePixelRatioHeaderValue ||
         m_devicePixelRatioHeaderValue <= 0.0) {
       m_devicePixelRatioHeaderValue = 1.0;
       m_hasDevicePixelRatioHeaderValue = false;
     }
   }
+
+  if (m_placeholderOption ==
+          PlaceholderOption::ShowAndReloadPlaceholderAlways &&
+      isEntireResource(this->response())) {
+    if (this->response().httpStatusCode() < 400 ||
+        this->response().httpStatusCode() >= 600) {
+      // 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.
+      m_placeholderOption = PlaceholderOption::DoNotReloadPlaceholder;
+    } else {
+      m_placeholderOption = PlaceholderOption::ReloadPlaceholderOnDecodeError;
+    }
+  }
 }
 
+bool ImageResource::shouldShowPlaceholder() const {
+  switch (m_placeholderOption) {
+    case PlaceholderOption::ShowAndReloadPlaceholderAlways:
+      return true;
+    case PlaceholderOption::ReloadPlaceholderOnDecodeError:
+    case PlaceholderOption::DoNotReloadPlaceholder:
+      return false;
+  }
+  NOTREACHED();
+  return false;
+}
+
+bool ImageResource::shouldReloadBrokenPlaceholder() const {
+  switch (m_placeholderOption) {
+    case PlaceholderOption::ShowAndReloadPlaceholderAlways:
+      return errorOccurred();
+    case PlaceholderOption::ReloadPlaceholderOnDecodeError:
+      return getStatus() == ResourceStatus::DecodeError;
+    case PlaceholderOption::DoNotReloadPlaceholder:
+      return false;
+  }
+  NOTREACHED();
+  return false;
+}
+
 static bool isLoFiImage(const ImageResource& resource) {
   if (!(resource.resourceRequest().previewsState() &
         WebURLRequest::ServerLoFiOn)) {
     return false;
   }
   return !resource.isLoaded() ||
          resource.response()
              .httpHeaderField("chrome-proxy-content-transform")
              .contains("empty-image");
 }
 
 void ImageResource::reloadIfLoFiOrPlaceholderImage(
     ResourceFetcher* fetcher,
     ReloadLoFiOrPlaceholderPolicy policy) {
   if (policy == kReloadIfNeeded && !shouldReloadBrokenPlaceholder())
     return;
 
-  if (!m_isPlaceholder && !isLoFiImage(*this))
+  if (m_placeholderOption == PlaceholderOption::DoNotReloadPlaceholder &&
+      !isLoFiImage(*this))
     return;
 
   // Prevent clients and observers from being notified of completion while the
   // reload is being scheduled, so that e.g. canceling an existing load in
   // progress doesn't cause clients and observers to be notified of completion
   // prematurely.
   DCHECK(!m_isSchedulingReload);
   m_isSchedulingReload = true;
 
   if (policy != kReloadAlwaysWithExistingCachePolicy)
     setCachePolicyBypassingCache();
 
   setPreviewsStateNoTransform();
 
-  if (m_isPlaceholder) {
-    m_isPlaceholder = false;
+  if (m_placeholderOption != PlaceholderOption::DoNotReloadPlaceholder)
     clearRangeRequestHeader();
-  }
+  m_placeholderOption = PlaceholderOption::DoNotReloadPlaceholder;
 
   if (isLoading()) {
     loader()->cancel();
     // Canceling the loader causes error() to be called, which in turn calls
     // clear() and notifyObservers(), so there's no need to call these again
     // here.
   } else {
     clearData();
     setEncodedSize(0);
     updateImage(nullptr, ImageResourceContent::ClearImageAndNotifyObservers,
@@ skipping 86 matching lines @@
     //    reloading in Step 3 due to notifyObservers()'s
     //    schedulingReloadOrShouldReloadBrokenPlaceholder() check.
     // 3. reloadIfLoFiOrPlaceholderImage() is called via ResourceFetcher
     //    (a) via didFinishLoading() called in decodeError(), or
     //    (b) after returning ImageResource::updateImage().
     decodeError(allDataReceived);
   }
 }
 
 }  // namespace blink