Remove blink::Resource::Type::LinkPrefetch and replace it by a flag

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
     License as published by the Free Software Foundation; either
@@ skipping 63 matching lines @@
         resourceHistogram.count(policy);                                                                                                                                    \
         break;                                                                                                                                                              \
     }
 
 #define DEFINE_RESOURCE_HISTOGRAM(prefix)                        \
     switch (factory.type()) {                                    \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, CSSStyleSheet)  \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Font)           \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Image)          \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, ImportResource) \
-        DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, LinkPrefetch)   \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, LinkPreload)    \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, MainResource)   \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Manifest)       \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Media)          \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Raw)            \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, Script)         \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, SVGDocument)    \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, TextTrack)      \
         DEFINE_SINGLE_RESOURCE_HISTOGRAM(prefix, XSLStyleSheet)  \
     }
@@ skipping 24 matching lines @@
     case Resource::Manifest:
         // Also late-body scripts discovered by the preload scanner (set explicitly in loadPriority)
         return ResourceLoadPriorityMedium;
     case Resource::Image:
     case Resource::LinkPreload:
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::SVGDocument:
         // Also async scripts (set explicitly in loadPriority)
         return ResourceLoadPriorityLow;
-    case Resource::LinkPrefetch:
-        return ResourceLoadPriorityVeryLow;
     }
 
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
 ResourceLoadPriority ResourceFetcher::computeLoadPriority(Resource::Type type, const FetchRequest& request, ResourcePriority::VisibilityStatus visibility)
 {
     ResourceLoadPriority priority = typeToPriority(type);
+    if (request.isPrefetch())
+        priority = ResourceLoadPriorityVeryLow;
 
     // Visible resources (images in practice) get a boost to High priority.
     if (visibility == ResourcePriority::Visible)
         priority = ResourceLoadPriorityHigh;
 
     // Resources before the first image are considered "early" in the document
     // and resources after the first image are "late" in the document.  Important to
     // note that this is based on when the preload scanner discovers a resource
     // for the most part so the main parser may not have reached the image element yet.
     if (type == Resource::Image)
@@ skipping 41 matching lines @@
     case Resource::Script:
         return WebURLRequest::RequestContextScript;
     case Resource::Font:
         return WebURLRequest::RequestContextFont;
     case Resource::Image:
         return WebURLRequest::RequestContextImage;
     case Resource::Raw:
         return WebURLRequest::RequestContextSubresource;
     case Resource::ImportResource:
         return WebURLRequest::RequestContextImport;
-    case Resource::LinkPrefetch:
-        return WebURLRequest::RequestContextPrefetch;
     case Resource::LinkPreload:
         return WebURLRequest::RequestContextSubresource;
     case Resource::TextTrack:
         return WebURLRequest::RequestContextTrack;
     case Resource::SVGDocument:
         return WebURLRequest::RequestContextImage;
     case Resource::Media: // TODO: Split this.
         return WebURLRequest::RequestContextVideo;
     case Resource::Manifest:
         return WebURLRequest::RequestContextManifest;
@@ skipping 208 matching lines @@
     TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(request.url()));
 
     if (!request.url().isValid())
         return nullptr;
 
     if (!context().canRequest(factory.type(), request.resourceRequest(), MemoryCache::removeFragmentIdentifierIfNeeded(request.url()), request.options(), request.forPreload(), request.getOriginRestriction()))
         return nullptr;
 
     unsigned long identifier = createUniqueIdentifier();
     request.mutableResourceRequest().setPriority(computeLoadPriority(factory.type(), request, ResourcePriority::NotVisible));
+    if (request.isPrefetch()) {
+        request.mutableResourceRequest().setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
+        request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextPrefetch);
+    }
     initializeResourceRequest(request.mutableResourceRequest(), factory.type(), request.defer());
     context().willStartLoadingResource(identifier, request.mutableResourceRequest(), factory.type());
     if (!request.url().isValid())
         return nullptr;
 
     if (!request.forPreload()) {
         V8DOMActivityLogger* activityLogger = nullptr;
         if (request.options().initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest)
             activityLogger = V8DOMActivityLogger::currentActivityLogger();
         else
@@ skipping 103 matching lines @@
 {
     determineRequestContext(request, type, context().isMainFrame());
 }
 
 void ResourceFetcher::initializeResourceRequest(ResourceRequest& request, Resource::Type type, FetchRequest::DeferOption defer)
 {
     if (request.getCachePolicy() == WebCachePolicy::UseProtocolCachePolicy)
         request.setCachePolicy(context().resourceRequestCachePolicy(request, type, defer));
     if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
         determineRequestContext(request, type);
-    if (type == Resource::LinkPrefetch)
-        request.setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
 
     context().addAdditionalRequestHeaders(request, (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
 void ResourceFetcher::initializeRevalidation(ResourceRequest& revalidatingRequest, Resource* resource)
 {
     ASSERT(resource);
     ASSERT(memoryCache()->contains(resource));
     ASSERT(resource->isLoaded());
     ASSERT(resource->canUseCacheValidator());
@@ skipping 753 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