Changeset 208049 in webkit

Timestamp:

Oct 28, 2016 8:39:27 AM (8 years ago)

Author:

Antti Koivisto

Message:

Always use iOS preload behavior
​https://bugs.webkit.org/show_bug.cgi?id=164127

Reviewed by Andreas Kling.

Source/WebCore:

On non-iOS platforms we were delaying issuing lower priority preload (images mostly) until document has body.
This should be unnecessary as networking layer prioritization should ensure higher priority resources are
loaded earlier. Testing on iOS has showed that more aggressive behavior is a win.

This patch switches to iOS behavior on all platforms (and simplified the logic).

• html/parser/HTMLResourcePreloader.cpp:

(WebCore::HTMLResourcePreloader::preload):

• loader/LinkLoader.cpp:

(WebCore::LinkLoader::preloadIfNeeded):

• loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::performPostLoadActions):
(WebCore::CachedResourceLoader::preload):
(WebCore::CachedResourceLoader::isPreloaded):
(WebCore::CachedResourceLoader::checkForPendingPreloads): Deleted.
(WebCore::CachedResourceLoader::requestPreload): Deleted.
(WebCore::CachedResourceLoader::clearPendingPreloads): Deleted.

• loader/cache/CachedResourceLoader.h:

LayoutTests:

• http/tests/webgl/1.0.2/readPixelsBadArgs-expected.txt:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/http/tests/webgl/1.0.2/readPixelsBadArgs-expected.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/html/parser/HTMLResourcePreloader.cpp (modified) (1 diff)
• Source/WebCore/loader/LinkLoader.cpp (modified) (1 diff)
• Source/WebCore/loader/cache/CachedResourceLoader.cpp (modified) (4 diffs)
• Source/WebCore/loader/cache/CachedResourceLoader.h (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2016-10-28  Antti Koivisto  <antti@apple.com>
+
+        Always use iOS preload behavior
+        https://bugs.webkit.org/show_bug.cgi?id=164127
+
+        Reviewed by Andreas Kling.
+
+        * http/tests/webgl/1.0.2/readPixelsBadArgs-expected.txt:
+
 2016-10-28  Antoine Quint  <graouts@apple.com>
 

trunk/LayoutTests/http/tests/webgl/1.0.2/readPixelsBadArgs-expected.txt

@@ +1 @@
+Blocked access to external URL http://www.opengl.org/img/opengl_logo.jpg
 Blocked access to external URL http://www.opengl.org/img/opengl_logo.jpg
 This test runs the WebGL Test listed below in an iframe and reports PASS or FAIL.

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-10-28  Antti Koivisto  <antti@apple.com>
+
+        Always use iOS preload behavior
+        https://bugs.webkit.org/show_bug.cgi?id=164127
+
+        Reviewed by Andreas Kling.
+
+        On non-iOS platforms we were delaying issuing lower priority preload (images mostly) until document has body.
+        This should be unnecessary as networking layer prioritization should ensure higher priority resources are
+        loaded earlier. Testing on iOS has showed that more aggressive behavior is a win.
+
+        This patch switches to iOS behavior on all platforms (and simplified the logic).
+
+        * html/parser/HTMLResourcePreloader.cpp:
+        (WebCore::HTMLResourcePreloader::preload):
+        * loader/LinkLoader.cpp:
+        (WebCore::LinkLoader::preloadIfNeeded):
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::performPostLoadActions):
+        (WebCore::CachedResourceLoader::preload):
+        (WebCore::CachedResourceLoader::isPreloaded):
+        (WebCore::CachedResourceLoader::checkForPendingPreloads): Deleted.
+        (WebCore::CachedResourceLoader::requestPreload): Deleted.
+        (WebCore::CachedResourceLoader::clearPendingPreloads): Deleted.
+        * loader/cache/CachedResourceLoader.h:
+
 2016-10-28  Youenn Fablet  <youenn@apple.com>
 

trunk/Source/WebCore/html/parser/HTMLResourcePreloader.cpp

@@ -69 +69 @@
         return;
 
-    m_document.cachedResourceLoader().preload(preload->resourceType(), preload->resourceRequest(m_document), CachedResourceLoader::ImplicitPreload);
+    m_document.cachedResourceLoader().preload(preload->resourceType(), preload->resourceRequest(m_document));
 }
 

trunk/Source/WebCore/loader/LinkLoader.cpp

@@ -163 +163 @@
 
     linkRequest.setAsPotentiallyCrossOrigin(crossOriginMode, document);
-    CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest), CachedResourceLoader::ExplicitPreload);
+    CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest));
 
     if (cachedLinkResource)

trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

@@ -1190 +1190 @@
 void CachedResourceLoader::performPostLoadActions()
 {
-    checkForPendingPreloads();
-
     platformStrategies()->loaderStrategy()->servePendingRequests();
 }
@@ -1212 +1210 @@
 }
 
-CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request, PreloadType preloadType)
-{
-    // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
-    // FIXME: We should consider adding a setting to toggle aggressive preloading behavior as opposed
-    // to making this behavior specific to iOS.
-#if !PLATFORM(IOS)
-    bool hasRendering = m_document->bodyOrFrameset() && m_document->renderView();
-    bool canBlockParser = type == CachedResource::Script || type == CachedResource::CSSStyleSheet;
-    if (!hasRendering && !canBlockParser && preloadType == ImplicitPreload) {
-        // Don't preload subresources that can't block the parser before we have something to draw.
-        // This helps prevent preloads from delaying first display when bandwidth is limited.
-        PendingPreload pendingPreload = { type, WTFMove(request) };
-        m_pendingPreloads.append(pendingPreload);
-        return nullptr;
-    }
-#else
-    UNUSED_PARAM(preloadType);
-#endif
-    return requestPreload(type, WTFMove(request));
-}
-
-void CachedResourceLoader::checkForPendingPreloads()
-{
-    if (m_pendingPreloads.isEmpty())
-        return;
-    auto* body = m_document->bodyOrFrameset();
-    if (!body || !body->renderer())
-        return;
-#if PLATFORM(IOS)
-    // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
-    // So, we should never have any pending preloads.
-    // FIXME: We should look to avoid compiling this code entirely when building for iOS.
-    ASSERT_NOT_REACHED();
-#endif
-    while (!m_pendingPreloads.isEmpty()) {
-        PendingPreload preload = m_pendingPreloads.takeFirst();
-        // Don't request preload if the resource already loaded normally (this will result in double load if the page is being reloaded with cached results ignored).
-        if (!cachedResource(preload.m_request.resourceRequest().url()))
-            requestPreload(preload.m_type, WTFMove(preload.m_request));
-    }
-    m_pendingPreloads.clear();
-}
-
-CachedResourceHandle<CachedResource> CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest&& request)
+CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
 {
     if (request.charset().isEmpty() && (type == CachedResource::Script || type == CachedResource::CSSStyleSheet))
@@ -1288 +1243 @@
         }
     }
-
-    for (auto& pendingPreload : m_pendingPreloads) {
-        if (pendingPreload.m_request.resourceRequest().url() == url)
-            return true;
-    }
     return false;
 }
@@ -1311 +1261 @@
     }
     m_preloads = nullptr;
-}
-
-void CachedResourceLoader::clearPendingPreloads()
-{
-    m_pendingPreloads.clear();
 }
 

trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

@@ -131 +131 @@
     WEBCORE_EXPORT bool isPreloaded(const String& urlString) const;
     void clearPreloads();
-    void clearPendingPreloads();
-    enum PreloadType { ImplicitPreload, ExplicitPreload };
-    CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&, PreloadType);
-    void checkForPendingPreloads();
+    CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&);
     void printPreloadStats();
 
@@ -158 +155 @@
     CachedResourceHandle<CachedResource> revalidateResource(CachedResourceRequest&&, CachedResource&);
     CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&&);
-    CachedResourceHandle<CachedResource> requestPreload(CachedResource::Type, CachedResourceRequest&&);
 
     void prepareFetch(CachedResource::Type, CachedResourceRequest&);
@@ -192 +188 @@
     
     std::unique_ptr<ListHashSet<CachedResource*>> m_preloads;
-    struct PendingPreload {
-        CachedResource::Type m_type;
-        CachedResourceRequest m_request;
-    };
-    Deque<PendingPreload> m_pendingPreloads;
 
     Timer m_garbageCollectDocumentResourcesTimer;