Remove DeferredByClient

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 21 matching lines @@
 #include "core/events/Event.h"
 #include "core/events/EventSender.h"
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/HTMLImageElement.h"
+#include "core/html/ImageDocument.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/layout/LayoutImage.h"
 #include "core/layout/LayoutVideo.h"
 #include "core/layout/svg/LayoutSVGImage.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/Logging.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/WebCachePolicy.h"
@@ skipping 92 matching lines @@
     WeakPtrFactory<Task> m_weakFactory;
     ReferrerPolicy m_referrerPolicy;
 };
 
 ImageLoader::ImageLoader(Element* element)
     : m_element(element)
     , m_derefElementTimer(this, &ImageLoader::timerFired)
     , m_hasPendingLoadEvent(false)
     , m_hasPendingErrorEvent(false)
     , m_imageComplete(true)
-    , m_loadingImageDocument(false)

[yhirano, 2016/04/20 08:42:41]

Can you tell me why you deleted this statement?

[Nate Chapin, 2016/04/21 18:52:46]

It's a mistake. My first pass deleted this variable, and I missed re-adding it
here.

     , m_elementIsProtected(false)
     , m_suppressErrorEvents(false)
 {
     WTF_LOG(Timers, "new ImageLoader %p", this);
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 ImageLoader::~ImageLoader()
 {
 }
@@ skipping 110 matching lines @@
     AtomicString imageSourceURL = m_element->imageSourceURL();
     KURL url = imageSourceToKURL(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) {
             resourceRequest.setCachePolicy(WebCachePolicy::BypassingCache);
             resourceRequest.setLoFiState(WebURLRequest::LoFiOff);
-            // ImageLoader defers the load of images when in an ImageDocument.
-            // Don't defer this load on a forced reload.
-            m_loadingImageDocument = false;
         }
 
         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());
 
-        // Prevent the immediate 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 the ImageResource.
-        if (m_loadingImageDocument) {
-            request.setDefer(FetchRequest::DeferredByClient);
-            request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
-        }
-
         newImage = ImageResource::fetch(request, document.fetcher());
-        if (m_loadingImageDocument && newImage)
-            newImage->setStatus(Resource::Pending);
 
         if (!newImage && !pageIsBeingDismissed(&document)) {
             crossSiteOrCSPViolationOccurred(imageSourceURL);
             dispatchErrorEvent();
         } else {
             clearFailedLoadURL();
         }
     } else {
         if (!imageSourceURL.isNull()) {
             // Fire an error event if the url string is not empty, but the KURL is.
@@ skipping 47 matching lines @@
 {
     AtomicString imageSourceURL = m_element->imageSourceURL();
     m_suppressErrorEvents = (updateBehavior == UpdateSizeChanged);
 
     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) {
+        setImage(ImageResource::create(imageSourceToKURL(m_element->imageSourceURL())));

[yhirano, 2016/04/20 08:42:41]

ImageResource::create(const ResourceRequest&) is exposed for testing, according
to the comment. Is it OK to use it here?

[Nate Chapin, 2016/04/21 18:52:46]

It's safe to use, it's mostly a question of whether other non-testing callers
will misuse it. I think that's OK? I've removed the "Exposed for testing"
comment to match.

+        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();
     }
 
     KURL url = imageSourceToKURL(imageSourceURL);
     if (shouldLoadImmediately(url)) {
         doUpdateFromElement(DoNotBypassMainWorldCSP, updateBehavior, referrerPolicy);
@@ skipping 38 matching lines @@
 
 bool ImageLoader::shouldLoadImmediately(const KURL& url) const
 {
     // We force any image loads which might require alt content through the asynchronous path so that we can add the shadow DOM
     // for the alt-text content when style recalc is over and DOM mutation is allowed again.
     if (!url.isNull()) {
         Resource* resource = memoryCache()->resourceForURL(url, m_element->document().fetcher()->getCacheIdentifier());
         if (resource && !resource->errorOccurred())
             return true;
     }
-    return (m_loadingImageDocument || isHTMLObjectElement(m_element) || isHTMLEmbedElement(m_element) || url.protocolIsData());
+    return (isHTMLObjectElement(m_element) || isHTMLEmbedElement(m_element) || url.protocolIsData());
 }
 
 void ImageLoader::imageNotifyFinished(ImageResource* resource)
 {
     WTF_LOG(Timers, "ImageLoader::imageNotifyFinished %p; m_hasPendingLoadEvent=%d",
         this, m_hasPendingLoadEvent);
 
     ASSERT(m_failedLoadURL.isEmpty());
     ASSERT(resource == m_image.get());
 
@@ skipping 162 matching lines @@
 
 void ImageLoader::elementDidMoveToNewDocument()
 {
     if (m_loadDelayCounter)
         m_loadDelayCounter->documentChanged(m_element->document());
     clearFailedLoadURL();
     setImage(0);
 }
 
 } // namespace blink