[test] Resources served from MemoryCache - early exit

third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 470 matching lines @@
 }
 
 Resource* ResourceFetcher::requestResource(
     FetchRequest& request,
     const ResourceFactory& factory,
     const SubstituteData& substituteData) {
   SCOPED_BLINK_UMA_HISTOGRAM_TIMER("Blink.Fetch.RequestResourceTime");
   DCHECK(request.options().synchronousPolicy == RequestAsynchronously ||
          factory.type() == Resource::Raw ||
          factory.type() == Resource::XSLStyleSheet);
+  TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
+               urlForTraceEvent(request.url()));
 
   context().populateRequestData(request.mutableResourceRequest());
   if (request.resourceRequest().httpHeaderField("Upgrade-Insecure-Requests") !=
       AtomicString("1")) {
     context().modifyRequestForCSP(request.mutableResourceRequest());
   }
   context().addClientHintsIfNecessary(request);
   context().addCSPHeaderIfNecessary(factory.type(), request);
 
-  TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url",
-               urlForTraceEvent(request.url()));
-
   if (!request.url().isValid())
     return nullptr;
 
   unsigned long identifier = createUniqueIdentifier();
+
+  // Potentially early return if this request matches a preload. We need to be
+  // careful to ensure that the preload request matches the various security
+  // properties of the load.
+  Resource* originalResource(nullptr);
+  originalResource =
+      memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
+  if (originalResource) {
+    const RevalidationPolicy policy = determineRevalidationPolicy(
+        factory.type(), request, originalResource, false);
+    if (policy == Use) {
+      if (originalResource->isLinkPreload() && !request.isLinkPreload())
+        originalResource->setLinkPreload(false);
+      moveCachedNonBlockingResourceToBlocking(originalResource, request);
+      requestLoadStarted(identifier, originalResource, request,
+                         ResourceLoadingFromCache, false);
+      return originalResource;
+    }
+  }
+
   request.mutableResourceRequest().setPriority(computeLoadPriority(
       factory.type(), request, ResourcePriority::NotVisible));
   initializeResourceRequest(request.mutableResourceRequest(), factory.type(),
                             request.defer());
 
   if (!context().canRequest(
           factory.type(), request.resourceRequest(),
           MemoryCache::removeFragmentIdentifierIfNeeded(request.url()),
           request.options(), request.forPreload(),
           request.getOriginRestriction())) {
@@ skipping 31 matching lines @@
   Resource* resource(nullptr);
   if (isStaticData) {
     resource = resourceForStaticData(request, factory, substituteData);
     // Abort the request if the archive doesn't contain the resource, except in
     // the case of data URLs which might have resources such as fonts that need
     // to be decoded only on demand.  These data URLs are allowed to be
     // processed using the normal ResourceFetcher machinery.
     if (!resource && !isDataUrl && m_archive)
       return nullptr;
   }
+
+  // Only retrieve the Resource from MemoryCache if the url has been changed
+  // by the embedder.
   if (!resource) {
-    resource =
-        memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
+    if (!originalResource || request.url() != originalResource->url()) {
+      resource =
+          memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
+    } else {
+      resource = originalResource;
+    }
   }
 
   // See if we can use an existing resource from the cache. If so, we need to
   // move it to be load blocking.
   moveCachedNonBlockingResourceToBlocking(resource, request);
 
   const RevalidationPolicy policy = determineRevalidationPolicy(
       factory.type(), request, resource, isStaticData);
   TRACE_EVENT_INSTANT1("blink", "ResourceFetcher::determineRevalidationPolicy",
                        TRACE_EVENT_SCOPE_THREAD, "revalidationPolicy", policy);
@@ skipping 230 matching lines @@
   RecordSriResourceIntegrityMismatchEvent(CheckingForIntegrityMismatch);
   if (existingResource->mustRefetchDueToIntegrityMetadata(fetchRequest)) {
     RecordSriResourceIntegrityMismatchEvent(RefetchDueToIntegrityMismatch);
     return Reload;
   }
 
   // Service Worker's CORS fallback message must not be cached.
   if (existingResource->response().wasFallbackRequiredByServiceWorker())
     return Reload;
 
-  // We already have a preload going for this URL.
-  if (fetchRequest.forPreload() && existingResource->isPreloaded())
-    return Use;
-
   // If the same URL has been loaded as a different type, we need to reload.
   if (existingResource->getType() != type) {
     // FIXME: If existingResource is a Preload and the new type is LinkPrefetch
     // We really should discard the new prefetch since the preload has more
     // specific type information! crbug.com/379893
     // fast/dom/HTMLLinkElement/link-and-subresource-test hits this case.
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to type mismatch.";
     return Reload;
   }
 
+  // We already have a preload going for this URL.
+  if (fetchRequest.forPreload() && existingResource->isPreloaded())
+    return Use;
+
   // Do not load from cache if images are not enabled. There are two general
   // cases:
   //
   // 1. Images are disabled. Don't ever load images, even if the image is cached
   // or it is a data: url. In this case, we "Reload" the image, then defer it
   // with resourceNeedsLoad() so that it never actually goes to the network.
   //
   // 2. Images are enabled, but not loaded automatically. In this case, we will
   // Use cached resources or data: urls, but will similarly fall back to a
   // deferred network load if we don't have the data available without a network
@@ skipping 776 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink