Dont preload from link headers if the response came from MemoryCache

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

 /*
  * Copyright (C) 2013 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 33 matching lines @@
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorNetworkAgent.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
-#include "core/loader/LinkLoader.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/loader/NetworkHintsInterface.h"
 #include "core/loader/PingLoader.h"
 #include "core/loader/ProgressTracker.h"
 #include "core/loader/appcache/ApplicationCacheHost.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "core/page/Page.h"
 #include "core/svg/graphics/SVGImageChromeClient.h"
 #include "core/timing/DOMWindowPerformance.h"
 #include "core/timing/Performance.h"
@@ skipping 248 matching lines @@
     if (!redirectResponse.isNull())
         prepareRequest(identifier, request, redirectResponse);
     TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceSendRequest", TRACE_EVENT_SCOPE_THREAD, "data", InspectorSendRequestEvent::data(identifier, frame(), request));
     InspectorInstrumentation::willSendRequest(frame(), identifier, masterDocumentLoader(), request, redirectResponse, initiatorInfo);
     if (frame()->frameScheduler())
         frame()->frameScheduler()->didStartLoading(identifier);
 }
 
 void FrameFetchContext::dispatchDidReceiveResponse(unsigned long identifier, const ResourceResponse& response, WebURLRequest::FrameType frameType, WebURLRequest::RequestContext requestContext, Resource* resource)
 {
-    LinkLoader::CanLoadResources resourceLoadingPolicy = LinkLoader::LoadResourcesAndPreconnect;
-    MixedContentChecker::checkMixedPrivatePublic(frame(), response.remoteIPAddress());
-    if (m_documentLoader == frame()->loader().provisionalDocumentLoader()) {
-        ResourceFetcher* fetcher = nullptr;
-        if (frame()->document())
-            fetcher = frame()->document()->fetcher();
-        m_documentLoader->clientHintsPreferences().updateFromAcceptClientHintsHeader(response.httpHeaderField(HTTPNames::Accept_CH), fetcher);
-        // When response is received with a provisional docloader, the resource haven't committed yet, and we cannot load resources, only preconnect.
-        resourceLoadingPolicy = LinkLoader::DoNotLoadResources;
-    }
-    LinkLoader::loadLinksFromHeader(response.httpHeaderField(HTTPNames::Link), response.url(), frame()->document(), NetworkHintsInterfaceImpl(), resourceLoadingPolicy, nullptr);
-
-    if (response.hasMajorCertificateErrors())
-        MixedContentChecker::handleCertificateError(frame(), response, frameType, requestContext);
-
-    frame()->loader().progress().incrementProgress(identifier, response);
-    frame()->loader().client()->dispatchDidReceiveResponse(m_documentLoader, identifier, response);
-    TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD, "data", InspectorReceiveResponseEvent::data(identifier, frame(), response));
-    DocumentLoader* documentLoader = masterDocumentLoader();
-    InspectorInstrumentation::didReceiveResourceResponse(frame(), identifier, documentLoader, response, resource);
-    // It is essential that inspector gets resource response BEFORE console.
-    frame()->console().reportResourceResponseReceived(documentLoader, identifier, response);
+    dispatchDidReceiveResponseInternal(identifier, response, frameType, requestContext, resource, LinkLoader::LoadResourcesAndPreconnect);
 }
 
 void FrameFetchContext::dispatchDidReceiveData(unsigned long identifier, const char* data, int dataLength, int encodedDataLength)
 {
     frame()->loader().progress().incrementProgress(identifier, dataLength);
     TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceReceivedData", TRACE_EVENT_SCOPE_THREAD, "data", InspectorReceiveDataEvent::data(identifier, frame(), encodedDataLength));
     InspectorInstrumentation::didReceiveData(frame(), identifier, data, dataLength, encodedDataLength);
 }
 
 void FrameFetchContext::dispatchDidDownloadData(unsigned long identifier, int dataLength, int encodedDataLength)
@@ skipping 28 matching lines @@
 }
 
 void FrameFetchContext::dispatchDidLoadResourceFromMemoryCache(unsigned long identifier, Resource* resource, WebURLRequest::FrameType frameType, WebURLRequest::RequestContext requestContext)
 {
     ResourceRequest request(resource->url());
     frame()->loader().client()->dispatchDidLoadResourceFromMemoryCache(request, resource->response());
     dispatchWillSendRequest(identifier, request, ResourceResponse(), resource->options().initiatorInfo);
 
     InspectorInstrumentation::markResourceAsCached(frame(), identifier);
     if (!resource->response().isNull())
-        dispatchDidReceiveResponse(identifier, resource->response(), frameType, requestContext, resource);
+        dispatchDidReceiveResponseInternal(identifier, resource->response(), frameType, requestContext, resource, LinkLoader::DoNotLoadResources);

[Charlie Harrison, 2016/07/19 21:35:39]

To answer your last comment: This line is the functional change besides for the
sanity checking of "url == baseURL". We forward calls from
dispatchDidLoadResourceFromMemory cache to dispatchDidReceiveResponseInternal
with the policy that we shouldn't be loading anything from links.

[Yoav Weiss, 2016/07/19 21:43:02]

OK, so that's what I missed! :)

 
     if (resource->encodedSize() > 0)
         dispatchDidReceiveData(identifier, 0, resource->encodedSize(), 0);
 
     dispatchDidFinishLoading(identifier, 0, 0);
 }
 
 bool FrameFetchContext::shouldLoadNewResource(Resource::Type type) const
 {
     if (!m_documentLoader)
@@ skipping 397 matching lines @@
         return ResourceLoadPriorityVeryLow;
 
     return priority;
 }
 
 WebTaskRunner* FrameFetchContext::loadingTaskRunner() const
 {
     return frame()->frameScheduler()->loadingTaskRunner();
 }
 
+void FrameFetchContext::dispatchDidReceiveResponseInternal(unsigned long identifier, const ResourceResponse& response, WebURLRequest::FrameType frameType, WebURLRequest::RequestContext requestContext, Resource* resource, LinkLoader::CanLoadResources resourceLoadingPolicy)

[Yoav Weiss, 2016/07/19 21:04:03]

Is there a functional change here? Or is this just a refactoring?

[Charlie Harrison, 2016/07/19 21:11:02]

No functional change, except to pull resourceLoadingPolicy into an argument. I
didn't want to do this in the base class because core/fetch should not know
about LinkLoader.

[Yoav Weiss, 2016/07/19 21:14:21]

I'm totally fine with this refactoring, just wasn't sure how it's related to
this patch.

+{
+    MixedContentChecker::checkMixedPrivatePublic(frame(), response.remoteIPAddress());
+    if (m_documentLoader == frame()->loader().provisionalDocumentLoader()) {
+        ResourceFetcher* fetcher = nullptr;
+        if (frame()->document())
+            fetcher = frame()->document()->fetcher();
+        m_documentLoader->clientHintsPreferences().updateFromAcceptClientHintsHeader(response.httpHeaderField(HTTPNames::Accept_CH), fetcher);
+        // When response is received with a provisional docloader, the resource haven't committed yet, and we cannot load resources, only preconnect.
+        resourceLoadingPolicy = LinkLoader::DoNotLoadResources;
+    }
+    LinkLoader::loadLinksFromHeader(response.httpHeaderField(HTTPNames::Link), response.url(), frame()->document(), NetworkHintsInterfaceImpl(), resourceLoadingPolicy, nullptr);
+
+    if (response.hasMajorCertificateErrors())
+        MixedContentChecker::handleCertificateError(frame(), response, frameType, requestContext);
+
+    frame()->loader().progress().incrementProgress(identifier, response);
+    frame()->loader().client()->dispatchDidReceiveResponse(m_documentLoader, identifier, response);
+    TRACE_EVENT_INSTANT1("devtools.timeline", "ResourceReceiveResponse", TRACE_EVENT_SCOPE_THREAD, "data", InspectorReceiveResponseEvent::data(identifier, frame(), response));
+    DocumentLoader* documentLoader = masterDocumentLoader();
+    InspectorInstrumentation::didReceiveResourceResponse(frame(), identifier, documentLoader, response, resource);
+    // It is essential that inspector gets resource response BEFORE console.
+    frame()->console().reportResourceResponseReceived(documentLoader, identifier, response);
+}
+
 DEFINE_TRACE(FrameFetchContext)
 {
     visitor->trace(m_document);
     visitor->trace(m_documentLoader);
     FetchContext::trace(visitor);
 }
 
 } // namespace blink