Add <link rel=preload> onload support for scripts and styles

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

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 38 matching lines @@
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/parser/HTMLDocumentParser.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/FrameFetchContext.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/loader/LinkLoader.h"
+#include "core/loader/LinkPreloadResourceClients.h"
 #include "core/loader/ProgressTracker.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "platform/HTTPNames.h"
 #include "platform/Logging.h"
 #include "platform/ThreadedDataReceiver.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/mhtml/ArchiveResource.h"
 #include "platform/mhtml/ArchiveResourceCollection.h"
@@ skipping 84 matching lines @@
 const ResourceRequest& DocumentLoader::request() const
 {
     return m_request;
 }
 
 const KURL& DocumentLoader::url() const
 {
     return m_request.url();
 }
 
-void DocumentLoader::startPreload(Resource::Type type, FetchRequest& request)
+void DocumentLoader::startPreload(Resource::Type type, FetchRequest& request, LinkLoader* linkLoader)

[Nate Chapin, 2016/01/13 23:52:23]

It seems like it would be cleaner to change startPreload() to return a
ResourcePtr<> here and let LinkLoader set up the client.

[Yoav Weiss, 2016/01/14 10:10:02]

Returning things to LinkLoader makes the call from LinkLoader significantly more
complex and forces other call sites of startPreload (HTMLResourcePreloader) to
know the size of LinkPreloadResourceClient. So it's easier to keep setting the
resourceClient here.

OTOH, I did clean up things quite a bit. Let me know if it works, and if not,
I'll change this to return the ResourceClient over.

[Nate Chapin, 2016/01/14 23:10:53]

I don't see how HTMLResourcePreload would need to know anything about
LinkPreloadResourceClient? LinkLoader knows the Resource::Type, so it knows
which (if any) LinkPreloadResourceClient is needed. Suppose
DocumentLoader::startPreload() and LinkLoader.cpp's preloadIfNeeded() are
changed to return a ResourcePtr<Resource>. LinkLoader::loadLink() can check
whether ResourcePtr<Resource> was in fact non-null and create the appropriate
LinkPreloadResourceClient with the Resource. Does that not work for some reason?

 {
     ResourcePtr<Resource> resource;
     switch (type) {
     case Resource::Image:
+        if (linkLoader)
+            linkLoader->setPreloadResourceClient(LinkPreloadImageResourceClient::create(linkLoader));
         resource = ImageResource::fetch(request, fetcher());
         break;
     case Resource::Script:
         resource = ScriptResource::fetch(request, fetcher());
+        if (linkLoader)
+            linkLoader->setPreloadResourceClient(LinkPreloadScriptResourceClient::create(linkLoader));
         break;
     case Resource::CSSStyleSheet:
+        if (linkLoader)
+            linkLoader->setPreloadResourceClient(LinkPreloadStyleResourceClient::create(linkLoader));
         resource = CSSStyleSheetResource::fetch(request, fetcher());
         break;
     case Resource::Font:
         resource = FontResource::fetch(request, fetcher());
         break;
     case Resource::Media:
         resource = RawResource::fetchMedia(request, fetcher());
         break;
     case Resource::TextTrack:
         resource = RawResource::fetchTextTrack(request, fetcher());
         break;
     case Resource::ImportResource:
         resource = RawResource::fetchImport(request, fetcher());
         break;
     case Resource::LinkSubresource:
         resource = RawResource::fetch(request, fetcher());
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
-    if (resource)
-        fetcher()->preloadStarted(resource.get());
+    if (!resource)
+        return;
+
+    if (linkLoader && linkLoader->preloadResourceClient())
+        linkLoader->preloadResourceClient()->callSetResource(resource.get());
+    fetcher()->preloadStarted(resource.get());
 }
 
 void DocumentLoader::didChangePerformanceTiming()
 {
     if (frame() && frame()->isMainFrame() && m_state >= Committed) {
         frameLoader()->client()->didChangePerformanceTiming();
     }
 }
 
 void DocumentLoader::updateForSameDocumentNavigation(const KURL& newURL, SameDocumentNavigationSource sameDocumentNavigationSource)
@@ skipping 636 matching lines @@
 {
     m_writer = createWriterFor(ownerDocument, init, mimeType(), m_writer ? m_writer->encoding() : emptyAtom, true, ForceSynchronousParsing);
     if (!source.isNull())
         m_writer->appendReplacingData(source);
     endWriting(m_writer.get());
 }
 
 DEFINE_WEAK_IDENTIFIER_MAP(DocumentLoader);
 
 } // namespace blink