DO NOT COMMIT: Experimental removal of encoded image data

third_party/WebKit/Source/core/loader/ImageLoader.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010 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.
  *
@@ skipping 136 matching lines @@
 
 ImageLoader::ImageLoader(Element* element)
     : m_element(element)
     , m_derefElementTimer(this, &ImageLoader::timerFired)
     , m_hasPendingLoadEvent(false)
     , m_hasPendingErrorEvent(false)
     , m_imageComplete(true)
     , m_loadingImageDocument(false)
     , m_elementIsProtected(false)
     , m_suppressErrorEvents(false)
+    , m_suppressEvents(false)
 {
     RESOURCE_LOADING_DVLOG(1) << "new ImageLoader " << this;
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 ImageLoader::~ImageLoader()
 {
 }
 
 void ImageLoader::dispose()
@@ skipping 58 matching lines @@
     CrossOriginAttributeValue crossOrigin = crossOriginAttributeValue(element.fastGetAttribute(HTMLNames::crossoriginAttr));
     if (crossOrigin != CrossOriginAttributeNotSet)
         request.setCrossOriginAccessControl(element.document().getSecurityOrigin(), crossOrigin);
 
     if (clientHintsPreferences.shouldSendResourceWidth() && isHTMLImageElement(element))
         request.setResourceWidth(toHTMLImageElement(element).getResourceWidth());
 }
 
 inline void ImageLoader::dispatchErrorEvent()
 {
+    if (m_suppressEvents) {
+        return;
+    }
     m_hasPendingErrorEvent = true;
     errorEventSender().dispatchEventSoon(this);
 }
 
 inline void ImageLoader::crossSiteOrCSPViolationOccurred(AtomicString imageSourceURL)
 {
     m_failedLoadURL = imageSourceURL;
 }
 
 inline void ImageLoader::clearFailedLoadURL()
@@ skipping 27 matching lines @@
     Document& document = m_element->document();
     if (!document.isActive())
         return;
 
     AtomicString imageSourceURL = m_element->imageSourceURL();
     ImageResource* newImage = nullptr;
     if (!url.isNull()) {
         // Unlike raw <img>, we block mixed content inside of <picture> or <img srcset>.
         ResourceLoaderOptions resourceLoaderOptions = ResourceFetcher::defaultResourceOptions();
         ResourceRequest resourceRequest(url);
-        if (updateBehavior == UpdateForcedReload) {
+        switch (updateBehavior) {
+        case UpdateForcedReload:
             resourceRequest.setCachePolicy(WebCachePolicy::BypassingCache);
             resourceRequest.setLoFiState(WebURLRequest::LoFiOff);
+            break;
+        case UpdateMyReload:
+            resourceRequest.setCachePolicy(WebCachePolicy::ReturnCacheDataElseLoad);
+            resourceRequest.setLoFiState(WebURLRequest::LoFiOff);
+            break;
+        default:
+            break;
         }
 
         if (referrerPolicy != ReferrerPolicyDefault)
             resourceRequest.setHTTPReferrer(SecurityPolicy::generateReferrer(referrerPolicy, url, document.outgoingReferrer()));
 
         if (isHTMLPictureElement(element()->parentNode()) || !element()->fastGetAttribute(HTMLNames::srcsetAttr).isNull())
             resourceRequest.setRequestContext(WebURLRequest::RequestContextImageSet);
         FetchRequest request(resourceRequest, element()->localName(), resourceLoaderOptions);
         configureRequest(request, bypassBehavior, *m_element, document.clientHintsPreferences());
 
@@ skipping 25 matching lines @@
         // Cancel error events that belong to the previous load, which is now cancelled by changing the src attribute.
         // If newImage is null and m_hasPendingErrorEvent is true, we know the error event has been just posted by
         // this load and we should not cancel the event.
         // FIXME: If both previous load and this one got blocked with an error, we can receive one error event instead of two.
         if (m_hasPendingErrorEvent && newImage) {
             errorEventSender().cancelEvent(this);
             m_hasPendingErrorEvent = false;
         }
 
         m_image = newImage;
-        m_hasPendingLoadEvent = newImage;
+        m_hasPendingLoadEvent = newImage && !m_suppressEvents;
         m_imageComplete = !newImage;
 
         updateLayoutObject();
         // If newImage exists and is cached, addObserver() will result in the load event
         // being queued to fire. Ensure this happens after beforeload is dispatched.
         if (newImage) {
             newImage->addObserver(this);
         }
         if (oldImage) {
             oldImage->removeObserver(this);
         }
     }
 
     if (LayoutImageResource* imageResource = layoutImageResource())
         imageResource->resetAnimation();
 
     // Only consider updating the protection ref-count of the Element immediately before returning
     // from this function as doing so might result in the destruction of this ImageLoader.
     updatedHasPendingEvent();
 }
 
 void ImageLoader::updateFromElement(UpdateFromElementBehavior updateBehavior, ReferrerPolicy referrerPolicy)
 {
     AtomicString imageSourceURL = m_element->imageSourceURL();
     m_suppressErrorEvents = (updateBehavior == UpdateSizeChanged);
+    m_suppressEvents = (updateBehavior == UpdateMyReload);
 
     if (updateBehavior == UpdateIgnorePreviousError)
         clearFailedLoadURL();
 
     if (!m_failedLoadURL.isEmpty() && imageSourceURL == m_failedLoadURL)
         return;
 
     // Prevent the creation of a ResourceLoader (and therefore a network
     // request) for ImageDocument loads. In this case, the image contents have already
     // been requested as a main resource and ImageDocumentParser will take care of
     // funneling the main resource bytes into m_image, so just create an ImageResource
     // to be populated later.
-    if (m_loadingImageDocument && updateBehavior != UpdateForcedReload) {
+    if (m_loadingImageDocument && updateBehavior != UpdateForcedReload && updateBehavior != UpdateMyReload) {
         setImage(ImageResource::create(imageSourceToKURL(m_element->imageSourceURL())));
         m_image->setStatus(Resource::Pending);
         return;
     }
 
     // If we have a pending task, we have to clear it -- either we're
     // now loading immediately, or we need to reset the task's state.
     if (m_pendingTask) {
         m_pendingTask->clearLoader();
         m_pendingTask.clear();
@@ skipping 207 matching lines @@
 
 bool ImageLoader::getImageAnimationPolicy(ImageAnimationPolicy& policy)
 {
     if (!element()->document().settings())
         return false;
 
     policy = element()->document().settings()->imageAnimationPolicy();
     return true;
 }
 
+void ImageLoader::requireReloading()
+{
+    updateFromElement(UpdateMyReload);
+}
+
 void ImageLoader::dispatchPendingLoadEvents()
 {
     loadEventSender().dispatchPendingEvents();
 }
 
 void ImageLoader::dispatchPendingErrorEvents()
 {
     errorEventSender().dispatchPendingEvents();
 }
 
 void ImageLoader::elementDidMoveToNewDocument()
 {
     if (m_loadDelayCounter)
         m_loadDelayCounter->documentChanged(m_element->document());
     clearFailedLoadURL();
     setImage(0);
 }
 
 } // namespace blink