Changeset 208049 in webkit


Ignore:
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:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r208042 r208049  
     12016-10-28  Antti Koivisto  <antti@apple.com>
     2
     3        Always use iOS preload behavior
     4        https://bugs.webkit.org/show_bug.cgi?id=164127
     5
     6        Reviewed by Andreas Kling.
     7
     8        * http/tests/webgl/1.0.2/readPixelsBadArgs-expected.txt:
     9
    1102016-10-28  Antoine Quint  <graouts@apple.com>
    211

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

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

  • trunk/Source/WebCore/ChangeLog

    r208046 r208049  
     12016-10-28  Antti Koivisto  <antti@apple.com>
     2
     3        Always use iOS preload behavior
     4        https://bugs.webkit.org/show_bug.cgi?id=164127
     5
     6        Reviewed by Andreas Kling.
     7
     8        On non-iOS platforms we were delaying issuing lower priority preload (images mostly) until document has body.
     9        This should be unnecessary as networking layer prioritization should ensure higher priority resources are
     10        loaded earlier. Testing on iOS has showed that more aggressive behavior is a win.
     11
     12        This patch switches to iOS behavior on all platforms (and simplified the logic).
     13
     14        * html/parser/HTMLResourcePreloader.cpp:
     15        (WebCore::HTMLResourcePreloader::preload):
     16        * loader/LinkLoader.cpp:
     17        (WebCore::LinkLoader::preloadIfNeeded):
     18        * loader/cache/CachedResourceLoader.cpp:
     19        (WebCore::CachedResourceLoader::performPostLoadActions):
     20        (WebCore::CachedResourceLoader::preload):
     21        (WebCore::CachedResourceLoader::isPreloaded):
     22        (WebCore::CachedResourceLoader::checkForPendingPreloads): Deleted.
     23        (WebCore::CachedResourceLoader::requestPreload): Deleted.
     24        (WebCore::CachedResourceLoader::clearPendingPreloads): Deleted.
     25        * loader/cache/CachedResourceLoader.h:
     26
    1272016-10-28  Youenn Fablet  <youenn@apple.com>
    228

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

    r207053 r208049  
    6969        return;
    7070
    71     m_document.cachedResourceLoader().preload(preload->resourceType(), preload->resourceRequest(m_document), CachedResourceLoader::ImplicitPreload);
     71    m_document.cachedResourceLoader().preload(preload->resourceType(), preload->resourceRequest(m_document));
    7272}
    7373

  • trunk/Source/WebCore/loader/LinkLoader.cpp

    r206903 r208049  
    163163
    164164    linkRequest.setAsPotentiallyCrossOrigin(crossOriginMode, document);
    165     CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest), CachedResourceLoader::ExplicitPreload);
     165    CachedResourceHandle<CachedResource> cachedLinkResource = document.cachedResourceLoader().preload(type.value(), WTFMove(linkRequest));
    166166
    167167    if (cachedLinkResource)

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

    r207871 r208049  
    11901190void CachedResourceLoader::performPostLoadActions()
    11911191{
    1192     checkForPendingPreloads();
    1193 
    11941192    platformStrategies()->loaderStrategy()->servePendingRequests();
    11951193}
    … …  
    12121210}
    12131211
    1214 CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request, PreloadType preloadType)
    1215 {
    1216     // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
    1217     // FIXME: We should consider adding a setting to toggle aggressive preloading behavior as opposed
    1218     // to making this behavior specific to iOS.
    1219 #if !PLATFORM(IOS)
    1220     bool hasRendering = m_document->bodyOrFrameset() && m_document->renderView();
    1221     bool canBlockParser = type == CachedResource::Script || type == CachedResource::CSSStyleSheet;
    1222     if (!hasRendering && !canBlockParser && preloadType == ImplicitPreload) {
    1223         // Don't preload subresources that can't block the parser before we have something to draw.
    1224         // This helps prevent preloads from delaying first display when bandwidth is limited.
    1225         PendingPreload pendingPreload = { type, WTFMove(request) };
    1226         m_pendingPreloads.append(pendingPreload);
    1227         return nullptr;
    1228     }
    1229 #else
    1230     UNUSED_PARAM(preloadType);
    1231 #endif
    1232     return requestPreload(type, WTFMove(request));
    1233 }
    1234 
    1235 void CachedResourceLoader::checkForPendingPreloads()
    1236 {
    1237     if (m_pendingPreloads.isEmpty())
    1238         return;
    1239     auto* body = m_document->bodyOrFrameset();
    1240     if (!body || !body->renderer())
    1241         return;
    1242 #if PLATFORM(IOS)
    1243     // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
    1244     // So, we should never have any pending preloads.
    1245     // FIXME: We should look to avoid compiling this code entirely when building for iOS.
    1246     ASSERT_NOT_REACHED();
    1247 #endif
    1248     while (!m_pendingPreloads.isEmpty()) {
    1249         PendingPreload preload = m_pendingPreloads.takeFirst();
    1250         // 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).
    1251         if (!cachedResource(preload.m_request.resourceRequest().url()))
    1252             requestPreload(preload.m_type, WTFMove(preload.m_request));
    1253     }
    1254     m_pendingPreloads.clear();
    1255 }
    1256 
    1257 CachedResourceHandle<CachedResource> CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest&& request)
     1212CachedResourceHandle<CachedResource> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
    12581213{
    12591214    if (request.charset().isEmpty() && (type == CachedResource::Script || type == CachedResource::CSSStyleSheet))
    … …  
    12881243        }
    12891244    }
    1290 
    1291     for (auto& pendingPreload : m_pendingPreloads) {
    1292         if (pendingPreload.m_request.resourceRequest().url() == url)
    1293             return true;
    1294     }
    12951245    return false;
    12961246}
    … …  
    13111261    }
    13121262    m_preloads = nullptr;
    1313 }
    1314 
    1315 void CachedResourceLoader::clearPendingPreloads()
    1316 {
    1317     m_pendingPreloads.clear();
    13181263}
    13191264

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

    r207817 r208049  
    131131    WEBCORE_EXPORT bool isPreloaded(const String& urlString) const;
    132132    void clearPreloads();
    133     void clearPendingPreloads();
    134     enum PreloadType { ImplicitPreload, ExplicitPreload };
    135     CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&, PreloadType);
    136     void checkForPendingPreloads();
     133    CachedResourceHandle<CachedResource> preload(CachedResource::Type, CachedResourceRequest&&);
    137134    void printPreloadStats();
    138135
    … …  
    158155    CachedResourceHandle<CachedResource> revalidateResource(CachedResourceRequest&&, CachedResource&);
    159156    CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, CachedResourceRequest&&);
    160     CachedResourceHandle<CachedResource> requestPreload(CachedResource::Type, CachedResourceRequest&&);
    161157
    162158    void prepareFetch(CachedResource::Type, CachedResourceRequest&);
    … …  
    192188   
    193189    std::unique_ptr<ListHashSet<CachedResource*>> m_preloads;
    194     struct PendingPreload {
    195         CachedResource::Type m_type;
    196         CachedResourceRequest m_request;
    197     };
    198     Deque<PendingPreload> m_pendingPreloads;
    199190
    200191    Timer m_garbageCollectDocumentResourcesTimer;
Note: See TracChangeset for help on using the changeset viewer.