Phase II Step 3: Reload LoFi/placeholder images via new ImageResource

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
@@ skipping 17 matching lines @@
 #include "core/fetch/ResourceFetcher.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoadingLog.h"
 #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/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebCachePolicy.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/StdLibExtras.h"
 #include <memory>
 #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
 
 class ImageResource::ImageResourceInfoImpl final
     : public GarbageCollectedFinalized<ImageResourceInfoImpl>,
       public ImageResourceInfo {
   USING_GARBAGE_COLLECTED_MIXIN(ImageResourceInfoImpl);
 
  public:
   ImageResourceInfoImpl(ImageResource* resource) : m_resource(resource) {
     DCHECK(m_resource);
   }
   DEFINE_INLINE_VIRTUAL_TRACE() {
     visitor->trace(m_resource);
     ImageResourceInfo::trace(visitor);
   }
 
  private:
   const KURL& url() const override { return m_resource->url(); }
-  bool isSchedulingReload() const override {
-    return m_resource->m_isSchedulingReload;
-  }
   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();
   }
   Resource::Status getStatus() const override {
     return m_resource->getStatus();
   }
   bool isPlaceholder() const override { return m_resource->isPlaceholder(); }
   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();
   }
+  const ImageResource* resourceForTest() const override { return m_resource; }
 
   void decodeError(bool allDataReceived) override {
     m_resource->decodeError(allDataReceived);
   }
   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(
       ResourceFetcher* fetcher,
       const KURL& url,
       const AtomicString& initiatorName) override {
     fetcher->emulateLoadStartedForInspector(m_resource.get(), url,
                                             WebURLRequest::RequestContextImage,
                                             initiatorName);
   }
+  bool reloadIfLoFiOrPlaceholderIfNeeded(
+      ResourceFetcher* fetcherForReload) override {
+    return m_resource->reloadIfLoFiOrPlaceholderImage(fetcherForReload,
+                                                      kReloadIfNeeded);
+  }
 
   const Member<ImageResource> m_resource;
 };
 
 class ImageResource::ImageResourceFactory : public ResourceFactory {
   STACK_ALLOCATED();
 
  public:
-  ImageResourceFactory(const FetchRequest& fetchRequest)
-      : ResourceFactory(Resource::Image), m_fetchRequest(&fetchRequest) {}
+  ImageResourceFactory(const FetchRequest& fetchRequest,
+                       ImageResourceContent* content)
+      : ResourceFactory(Resource::Image),
+        m_fetchRequest(&fetchRequest),
+        m_content(content) {}
 
   Resource* create(const ResourceRequest& request,
                    const ResourceLoaderOptions& options,
                    const String&) const override {
-    return new ImageResource(request, options, ImageResourceContent::create(),
-                             m_fetchRequest->placeholderImageRequestType() ==
-                                 FetchRequest::AllowPlaceholder);
+    return new ImageResource(
+        request, options,
+        m_content ? m_content.get() : ImageResourceContent::create(),
+        m_fetchRequest->placeholderImageRequestType() ==
+            FetchRequest::AllowPlaceholder);
   }
 
  private:
   // Weak, unowned pointer. Must outlive |this|.
   const FetchRequest* m_fetchRequest;
+  Persistent<ImageResourceContent> m_content;
 };
 
 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()) {
       ResourceRequestBlockedReason blockReason = fetcher->context().canRequest(
           Resource::Image, request.resourceRequest(), requestURL,
           request.options(), request.forPreload(),
           request.getOriginRestriction());
       if (blockReason == ResourceRequestBlockedReason::None)
         fetcher->context().sendImagePing(requestURL);
     }
     return nullptr;
   }
 
-  ImageResource* resource = toImageResource(
-      fetcher->requestResource(request, ImageResourceFactory(request)));
+  ImageResource* resource = toImageResource(fetcher->requestResource(
+      request, ImageResourceFactory(request, nullptr)));
   if (resource &&
       request.placeholderImageRequestType() != FetchRequest::AllowPlaceholder &&

[Nate Chapin, 2016/12/28 00:14:57]

This also seems like a case where we could have ImageResource override
canReuse() and not need to special case this.

[hiroshige, 2016/12/28 01:04:21]

Sounds good, I created a separate CL:
https://codereview.chromium.org/2602793003/ but it seems to cause behavior
changes. Let's discuss there.

       resource->m_isPlaceholder) {
     // 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(
+    ImageResource* reloadingResource = resource->reloadIfLoFiOrPlaceholderImage(
         fetcher, kReloadAlwaysWithExistingCachePolicy);
+    if (reloadingResource)
+      resource = reloadingResource;
   }
   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_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;
 }
 
 DEFINE_TRACE(ImageResource) {
   visitor->trace(m_multipartParser);
   visitor->trace(m_content);
   Resource::trace(visitor);
   MultipartImageResourceParser::Client::trace(visitor);
 }
 
-void ImageResource::checkNotify() {
-  // Don't notify clients of completion if this ImageResource is
-  // about to be reloaded.
-  if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
-    return;
-
-  Resource::checkNotify();
-}
-
 bool ImageResource::hasClientsOrObservers() const {
-  return Resource::hasClientsOrObservers() || getContent()->hasObservers();
+  return Resource::hasClientsOrObservers() ||
+         (getContent() && getContent()->hasObservers());
 }
 
 void ImageResource::didAddClient(ResourceClient* client) {
   DCHECK((m_multipartParser && isLoading()) || !data() ||
-         getContent()->hasImage());
-
-  // Don't notify observers and clients of completion if this ImageResource is
-  // about to be reloaded.
-  if (m_isSchedulingReload || shouldReloadBrokenPlaceholder())
-    return;
-
+         (getContent() && getContent()->hasImage()));
   Resource::didAddClient(client);
 }
 
 void ImageResource::destroyDecodedDataForFailedRevalidation() {
   // Clears the image, as we must create a new image for the failed
   // revalidation response.
   updateImage(nullptr, ImageResourceContent::ClearAndUpdateImage, false);
   setDecodedSize(0);
 }
 
 void ImageResource::destroyDecodedDataIfPossible() {
+  if (!getContent())
+    return;
   getContent()->destroyDecodedData();
   if (getContent()->hasImage() && !isPreloaded() &&
       getContent()->isRefetchableDataFromDiskCache()) {
     UMA_HISTOGRAM_MEMORY_KB("Memory.Renderer.EstimatedDroppableEncodedSize",
                             encodedSize() / 1024);
   }
 }
 
 void ImageResource::allClientsAndObserversRemoved() {
-  CHECK(!getContent()->hasImage() || !errorOccurred());
+  CHECK(!getContent() || !getContent()->hasImage() || !errorOccurred());
   // If possible, delay the resetting until back at the event loop. Doing so
   // after a conservative GC prevents resetAnimation() from upsetting ongoing
   // animation updates (crbug.com/613709)
-  if (!ThreadHeap::willObjectBeLazilySwept(this)) {
-    Platform::current()->currentThread()->getWebTaskRunner()->postTask(
-        BLINK_FROM_HERE, WTF::bind(&ImageResourceContent::doResetAnimation,
-                                   wrapWeakPersistent(getContent())));
-  } else {
-    getContent()->doResetAnimation();
+  if (getContent()) {
+    if (!ThreadHeap::willObjectBeLazilySwept(this)) {
+      Platform::current()->currentThread()->getWebTaskRunner()->postTask(
+          BLINK_FROM_HERE, WTF::bind(&ImageResourceContent::doResetAnimation,
+                                     wrapWeakPersistent(getContent())));
+    } else {
+      getContent()->doResetAnimation();
+    }
   }
   if (m_multipartParser)
     m_multipartParser->cancel();
   Resource::allClientsAndObserversRemoved();
 }
 
 PassRefPtr<const SharedBuffer> ImageResource::resourceBuffer() const {
   if (data())
     return data();
+  if (!getContent())
+    return nullptr;
   return getContent()->resourceBuffer();
 }
 
 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);
 
+    if (!getContent())
+      return;
+
     // Update the image immediately if needed.
     if (getContent()->shouldUpdateImageImmediately()) {
       updateImage(this->data(), ImageResourceContent::UpdateImage, false);
       return;
     }
 
     // For other cases, only update at |kFlushDelaySeconds| intervals. This
     // throttles how frequently we update |m_image| and how frequently we
     // inform the clients which causes an invalidation of this image. In other
     // words, we only invalidate this image every |kFlushDelaySeconds| seconds
@@ skipping 39 matching lines @@
   }
 
   memoryCache()->remove(this);
 }
 
 void ImageResource::updateImageAndClearBuffer() {
   updateImage(data(), ImageResourceContent::ClearAndUpdateImage, true);
   clearData();
 }
 
-void ImageResource::finish(double loadFinishTime) {
+void ImageResource::finish(double loadFinishTime,
+                           ResourceFetcher* fetcherForReload) {
   if (m_multipartParser) {
     m_multipartParser->finish();
     if (data())
       updateImageAndClearBuffer();
   } else {
-    updateImage(data(), ImageResourceContent::UpdateImage, true);
+    updateImage(data(), ImageResourceContent::UpdateImage, true,
+                fetcherForReload);
     // As encoded image data can be created from m_image  (see
     // ImageResource::resourceBuffer(), we don't have to keep m_data. Let's
     // clear this. As for the lifetimes of m_image and m_data, see this
     // document:
     // https://docs.google.com/document/d/1v0yTAZ6wkqX2U_M6BNIGUJpM1s0TIw1VsqpxoL7aciY/edit?usp=sharing
     clearData();
   }
-  Resource::finish(loadFinishTime);
+  Resource::finish(loadFinishTime, fetcherForReload);
 }
 
-void ImageResource::error(const ResourceError& error) {
+void ImageResource::error(const ResourceError& error,
+                          ResourceFetcher* fetcherForReload) {
   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::ClearImageOnly, true);
+  Resource::error(error, fetcherForReload);
+  updateImage(nullptr, ImageResourceContent::ClearImageOnly, true,
+              fetcherForReload);
 }
 
 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;
     }
   }
 }
 
+void ImageResource::detachContent() {
+  bool hasObservers = getContent() && getContent()->hasObservers();
+
+  m_content = nullptr;
+  clearData();
+  memoryCache()->remove(this);
+
+  if (hasObservers)
+    didRemoveClientOrObserver();
+}
+
 static bool isLoFiImage(const ImageResource& resource) {
   if (resource.resourceRequest().loFiState() != WebURLRequest::LoFiOn)
     return false;
   return !resource.isLoaded() ||
          resource.response()
              .httpHeaderField("chrome-proxy-content-transform")
              .contains("empty-image");
 }
 
-void ImageResource::reloadIfLoFiOrPlaceholderImage(
+ImageResource* ImageResource::reloadIfLoFiOrPlaceholderImage(
     ResourceFetcher* fetcher,
     ReloadLoFiOrPlaceholderPolicy policy) {
+  if (!fetcher)
+    return nullptr;
   if (policy == kReloadIfNeeded && !shouldReloadBrokenPlaceholder())
-    return;
+    return nullptr;
 
   if (!m_isPlaceholder && !isLoFiImage(*this))
-    return;
+    return nullptr;
 
-  // 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;
+  ImageResourceContent* content = getContent();
+  if (!content)
+    return nullptr;
+
+  // Creates request/options for new ImageResource for reloading.
+  ResourceRequest reloadingRequest = resourceRequest();
+  ResourceLoaderOptions reloadingOptions = options();
 
   if (policy != kReloadAlwaysWithExistingCachePolicy)
-    setCachePolicyBypassingCache();
-  setLoFiStateOff();
+    reloadingRequest.setCachePolicy(WebCachePolicy::BypassingCache);
+  reloadingRequest.setLoFiState(WebURLRequest::LoFiOff);
+  if (m_isPlaceholder)
+    reloadingRequest.clearHTTPHeaderField("range");
 
-  if (m_isPlaceholder) {
-    m_isPlaceholder = false;
-    clearRangeRequestHeader();
-  }
+  detachContent();
+  // Do not touch |this| after this point.
 
-  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::ClearImageOnly, false);
-  }
+  FetchRequest fetchRequest(
+      reloadingRequest, reloadingOptions.initiatorInfo.name, reloadingOptions);
+  DCHECK_EQ(FetchRequest::DisallowPlaceholder,
+            fetchRequest.placeholderImageRequestType());
+  fetchRequest.setEnforceNewResource();
 
-  setStatus(NotStarted);
-
-  DCHECK(m_isSchedulingReload);
-  m_isSchedulingReload = false;
-
-  fetcher->startLoad(this);
+  ImageResource* reloadingResource = toImageResource(fetcher->requestResource(
+      fetchRequest, ImageResourceFactory(fetchRequest, content)));
+  DCHECK(!reloadingResource || content == reloadingResource->getContent());
+  return reloadingResource;
 }
 
 void ImageResource::onePartInMultipartReceived(
     const ResourceResponse& response) {
   DCHECK(m_multipartParser);
 
   setResponse(response);
   if (m_multipartParsingState == MultipartParsingState::WaitingForFirstPart) {
     // We have nothing to do because we don't have any data.
     m_multipartParsingState = MultipartParsingState::ParsingFirstPart;
@@ skipping 41 matching lines @@
 
 ImageResourceContent* ImageResource::getContent() {
   return m_content;
 }
 
 const ImageResourceContent* ImageResource::getContent() const {
   return m_content;
 }
 
 ResourcePriority ImageResource::priorityFromObservers() {
+  if (!getContent())
+    return ResourcePriority();
   return getContent()->priorityFromObservers();
 }
 
 void ImageResource::updateImage(
     PassRefPtr<SharedBuffer> sharedBuffer,
     ImageResourceContent::UpdateImageOption updateImageOption,
-    bool allDataReceived) {
+    bool allDataReceived,
+    ResourceFetcher* fetcherForReload) {
+  if (!getContent())
+    return;
   if (!m_isUpdateImageCalled &&
       updateImageOption == ImageResourceContent::UpdateImage)
     updateImageOption = ImageResourceContent::ClearAndUpdateImage;
   m_isUpdateImageCalled = true;
   getContent()->updateImage(std::move(sharedBuffer), updateImageOption,
-                            allDataReceived);
+                            allDataReceived, fetcherForReload);
 }
 
 }  // namespace blink