Unify Resource loading status tracking

third_party/WebKit/Source/core/fetch/ResourceFetcher.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) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     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 245 matching lines @@
 
 bool ResourceFetcher::isControlledByServiceWorker() const
 {
     return context().isControlledByServiceWorker();
 }
 
 bool ResourceFetcher::resourceNeedsLoad(Resource* resource, const FetchRequest& request, RevalidationPolicy policy)
 {
     if (FetchRequest::DeferredByClient == request.defer())
         return false;
+    if (resource->isImage() && shouldDeferImageLoad(resource->url()))
+        return false;
     return policy != Use || resource->stillNeedsLoad();
 }
 
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::requestLoadStarted(Resource* resource, const FetchRequest& request, ResourceLoadStartType type, bool isStaticData)
 {
     if (type == ResourceLoadingFromCache && resource->getStatus() == Resource::Cached && !m_validatedURLs.contains(resource->url()))
@@ skipping 387 matching lines @@
     // If the same URL has been loaded as a different type, we need to reload.
     if (existingResource->getType() != type) {
         // FIXME: If existingResource is a Preload and the new type is LinkPrefetch
         // We really should discard the new prefetch since the preload has more
         // specific type information! crbug.com/379893
         // fast/dom/HTMLLinkElement/link-and-subresource-test hits this case.
         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to type mismatch.");
         return Reload;
     }
 
-    // Do not load from cache if images are not enabled. The load for this image will be blocked
-    // in ImageResource::load.
+    // Do not load from cache if images are not enabled.
+    // There are two general cases:
+    // 1. Images are disabled. Don't ever load images, even if the image is
+    //    cached or it is a data: url. In this case, we "Reload" the image,
+    //    then defer it with resourceNeedsLoad() so that it never actually
+    //    goes to the network.
+    // 2. Images are enabled, but not loaded automatically. In this case, we
+    //    will Use cached resources or data: urls, but will similarly fall back
+    //    to a deferred network load if we don't have the data available
+    //    without a network request. We check allowImage() here, which is
+    //    affected by m_imagesEnabled but not m_autoLoadImages, in order to
+    //    allow for this differing behavior.
+    // TODO(japhet): Can we get rid of one of these settings?
     if (FetchRequest::DeferredByClient == fetchRequest.defer())
         return Reload;
+    if (existingResource->isImage() && !context().allowImage(m_imagesEnabled, existingResource->url()))
+        return Reload;
 
     // Never use cache entries for downloadToFile / useStreamOnResponse
     // requests. The data will be delivered through other paths.
     if (request.downloadToFile() || request.useStreamOnResponse())
         return Reload;
 
     // If resource was populated from a SubstituteData load or data: url, use it.
     if (isStaticData)
         return Use;
 
@@ skipping 130 matching lines @@
         return;
 
     m_imagesEnabled = enable;
 
     if (!m_imagesEnabled)
         return;
 
     reloadImagesIfNotDeferred();
 }
 
-bool ResourceFetcher::clientDefersImage(const KURL& url) const
-{
-    return !context().allowImage(m_imagesEnabled, url);
-}
-
 bool ResourceFetcher::shouldDeferImageLoad(const KURL& url) const
 {
-    return clientDefersImage(url) || !m_autoLoadImages;
+    return !context().allowImage(m_imagesEnabled, url) || !m_autoLoadImages;
 }
 
 void ResourceFetcher::reloadImagesIfNotDeferred()
 {
     // TODO(japhet): Once oilpan ships, the const auto&
     // can be replaced with a Resource*. Also, null checking
     // the resource probably won't be necesssary.
     for (const auto& documentResource : m_documentResources) {
         Resource* resource = documentResource.value.get();
-        if (resource && resource->getType() == Resource::Image && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
+        if (resource && resource->getType() == Resource::Image && resource->stillNeedsLoad() && !shouldDeferImageLoad(resource->url()))
             const_cast<Resource*>(resource)->load(this);
     }
 }
 
 void ResourceFetcher::didLoadResource(Resource* resource)
 {
     context().didLoadResource(resource);
 }
 
 int ResourceFetcher::requestCount() const
@@ skipping 349 matching lines @@
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 #if ENABLE(OILPAN)
     visitor->trace(m_documentResources);
     visitor->trace(m_preloads);
     visitor->trace(m_resourceTimingInfoMap);
 #endif
 }
 
 } // namespace blink