Declarative resource hints go through mojo IPC to //content

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

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 27 matching lines @@
 #include "core/fetch/FetchRequest.h"
 #include "core/fetch/LinkFetchResource.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/CrossOriginAttribute.h"
 #include "core/html/LinkRelAttribute.h"
 #include "core/html/parser/HTMLPreloadScanner.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/DocumentLoader.h"
-#include "core/loader/NetworkHintsInterface.h"
 #include "core/loader/PrerenderHandle.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/Prerender.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/network/LinkHeader.h"
-#include "platform/network/NetworkHints.h"
+#include "public/platform/Platform.h"
 #include "public/platform/WebPrerender.h"
 
 namespace blink {
 
 static unsigned prerenderRelTypesFromRelAttribute(const LinkRelAttribute& relAttribute, Document& document)
 {
     unsigned result = 0;
     if (relAttribute.isLinkPrerender()) {
         result |= PrerenderRelTypePrerender;
         UseCounter::count(document, UseCounter::LinkRelPrerender);
@@ skipping 63 matching lines @@
 void LinkLoader::didSendDOMContentLoadedForPrerender()
 {
     m_client->didSendDOMContentLoadedForLinkPrerender();
 }
 
 enum LinkCaller {
     LinkCalledFromHeader,
     LinkCalledFromMarkup,
 };
 
-
-static void dnsPrefetchIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const NetworkHintsInterface& networkHintsInterface, LinkCaller caller)
+static void dnsPrefetchIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, LinkCaller caller)
 {
     if (relAttribute.isDNSPrefetch()) {
         UseCounter::count(document, UseCounter::LinkRelDnsPrefetch);
         if (caller == LinkCalledFromHeader)
             UseCounter::count(document, UseCounter::LinkHeaderDnsPrefetch);
         Settings* settings = document.settings();
         // FIXME: The href attribute of the link element can be in "//hostname" form, and we shouldn't attempt
         // to complete that as URL <https://bugs.webkit.org/show_bug.cgi?id=48857>.
         if (settings && settings->dnsPrefetchingEnabled() && href.isValid() && !href.isEmpty()) {
             if (settings->logDnsPrefetchAndPreconnect())
                 document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, DebugMessageLevel, String("DNS prefetch triggered for " + href.host())));
-            networkHintsInterface.dnsPrefetchHost(href.host());
+            Platform::current()->preresolve(href);
         }
     }
 }
 
-static void preconnectIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const CrossOriginAttributeValue crossOrigin, const NetworkHintsInterface& networkHintsInterface, LinkCaller caller)
+static void preconnectIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const CrossOriginAttributeValue crossOrigin, LinkCaller caller)
 {
     if (relAttribute.isPreconnect() && href.isValid() && href.protocolIsInHTTPFamily()) {
         UseCounter::count(document, UseCounter::LinkRelPreconnect);
         if (caller == LinkCalledFromHeader)
             UseCounter::count(document, UseCounter::LinkHeaderPreconnect);
         ASSERT(RuntimeEnabledFeatures::linkPreconnectEnabled());
         Settings* settings = document.settings();
         if (settings && settings->logDnsPrefetchAndPreconnect()) {
             document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, DebugMessageLevel, String("Preconnect triggered for ") + href.getString()));
             if (crossOrigin != CrossOriginAttributeNotSet) {
                 document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, DebugMessageLevel,
                     String("Preconnect CORS setting is ") + String((crossOrigin == CrossOriginAttributeAnonymous) ? "anonymous" : "use-credentials")));
             }
         }
-        networkHintsInterface.preconnectHost(href, crossOrigin);
+        Platform::current()->preconnect(href, crossOrigin != CrossOriginAttributeAnonymous, 1);
     }
 }
 
 bool LinkLoader::getResourceTypeFromAsAttribute(const String& as, Resource::Type& type)
 {
     ASSERT(as.lower() == as);
     if (as == "image") {
         type = Resource::Image;
     } else if (as == "script") {
         type = Resource::Script;
@@ skipping 112 matching lines @@
         linkRequest.setCrossOriginAccessControl(document.getSecurityOrigin(), crossOrigin);
     Settings* settings = document.settings();
     if (settings && settings->logPreload())
         document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, DebugMessageLevel, String("Preload triggered for " + href.host() + href.path())));
     linkRequest.setForPreload(true, monotonicallyIncreasingTime());
     linkRequest.setLinkPreload(true);
     linkRequest.setPriority(document.fetcher()->loadPriority(resourceType, linkRequest));
     return document.loader()->startPreload(resourceType, linkRequest);
 }
 
-void LinkLoader::loadLinksFromHeader(const String& headerValue, const KURL& baseURL, Document* document, const NetworkHintsInterface& networkHintsInterface,
-    CanLoadResources canLoadResources, ViewportDescriptionWrapper* viewportDescriptionWrapper)
+void LinkLoader::loadLinksFromHeader(const String& headerValue, const KURL& baseURL, Document* document, CanLoadResources canLoadResources, ViewportDescriptionWrapper* viewportDescriptionWrapper)
 {
     if (!document || headerValue.isEmpty())
         return;
     LinkHeaderSet headerSet(headerValue);
     for (auto& header : headerSet) {
         if (!header.valid() || header.url().isEmpty() || header.rel().isEmpty())
             continue;
 
         LinkRelAttribute relAttribute(header.rel());
         KURL url(baseURL, header.url());
         if (canLoadResources != OnlyLoadResources) {
             if (RuntimeEnabledFeatures::linkHeaderEnabled())
-                dnsPrefetchIfNeeded(relAttribute, url, *document, networkHintsInterface, LinkCalledFromHeader);
+                dnsPrefetchIfNeeded(relAttribute, url, *document, LinkCalledFromHeader);
 
             if (RuntimeEnabledFeatures::linkPreconnectEnabled())
-                preconnectIfNeeded(relAttribute, url, *document, crossOriginAttributeValue(header.crossOrigin()), networkHintsInterface, LinkCalledFromHeader);
+                preconnectIfNeeded(relAttribute, url, *document, crossOriginAttributeValue(header.crossOrigin()), LinkCalledFromHeader);
         }
         if (canLoadResources != DoNotLoadResources) {
             bool errorOccurred = false;
             if (RuntimeEnabledFeatures::linkPreloadEnabled()) {
                 ViewportDescription* viewportDescription = (viewportDescriptionWrapper && viewportDescriptionWrapper->set) ? &(viewportDescriptionWrapper->description) : nullptr;
                 preloadIfNeeded(relAttribute, url, *document, header.as(), header.mimeType(), header.media(), crossOriginAttributeValue(header.crossOrigin()), LinkCalledFromHeader, errorOccurred, viewportDescription);
             }
         }
         // TODO(yoav): Add more supported headers as needed.
     }
 }
 
 bool LinkLoader::loadLink(const LinkRelAttribute& relAttribute, CrossOriginAttributeValue crossOrigin, const String& type,
-    const String& as, const String& media, const KURL& href, Document& document, const NetworkHintsInterface& networkHintsInterface)
+    const String& as, const String& media, const KURL& href, Document& document)
 {
     // TODO(yoav): Do all links need to load only after they're in document???
 
     // TODO(yoav): Convert all uses of the CrossOriginAttribute to CrossOriginAttributeValue. crbug.com/486689
     // FIXME(crbug.com/463266): We're ignoring type here, for everything but preload. Maybe we shouldn't.
-    dnsPrefetchIfNeeded(relAttribute, href, document, networkHintsInterface, LinkCalledFromMarkup);
+    dnsPrefetchIfNeeded(relAttribute, href, document, LinkCalledFromMarkup);
 
-    preconnectIfNeeded(relAttribute, href, document, crossOrigin, networkHintsInterface, LinkCalledFromMarkup);
+    preconnectIfNeeded(relAttribute, href, document, crossOrigin, LinkCalledFromMarkup);
 
     bool errorOccurred = false;
     if (m_client->shouldLoadLink())
         createLinkPreloadResourceClient(preloadIfNeeded(relAttribute, href, document, as, type, media, crossOrigin, LinkCalledFromMarkup, errorOccurred, nullptr));
     if (errorOccurred)
         m_linkLoadingErrorTimer.startOneShot(0, BLINK_FROM_HERE);
 
     if (href.isEmpty() || !href.isValid())
         released();
 
@@ skipping 39 matching lines @@
 DEFINE_TRACE(LinkLoader)
 {
     visitor->trace(m_client);
     visitor->trace(m_prerender);
     visitor->trace(m_linkPreloadResourceClient);
     ResourceOwner<Resource, ResourceClient>::trace(visitor);
     PrerenderClient::trace(visitor);
 }
 
 } // namespace blink