Remove resource type-specific fetching logic from ResourceFetcher

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 10 matching lines @@
     Boston, MA 02110-1301, USA.
 
     This class provides all functionality needed for loading images, style sheets and html
     pages from the web. It has a memory cache for these objects.
 */
 
 #include "config.h"
 #include "core/fetch/ResourceFetcher.h"
 
 #include "bindings/core/v8/V8DOMActivityLogger.h"
-#include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/CrossOriginAccessControl.h"
-#include "core/fetch/DocumentResource.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
-#include "core/fetch/FontResource.h"
-#include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
-#include "core/fetch/RawResource.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoaderSet.h"
-#include "core/fetch/ScriptResource.h"
-#include "core/fetch/SubstituteData.h"
 #include "core/fetch/UniqueIdentifier.h"
-#include "core/fetch/XSLStyleSheetResource.h"
 #include "core/timing/ResourceTimingInfo.h"
 #include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/mhtml/ArchiveResource.h"
 #include "platform/mhtml/ArchiveResourceCollection.h"
 #include "platform/weborigin/KnownPorts.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 #define PRELOAD_DEBUG 0
 
 using blink::WebURLRequest;
 
 namespace blink {
 
-static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
-{
-    switch (type) {
-    case Resource::Image:
-        return new ImageResource(request);
-    case Resource::CSSStyleSheet:
-        return new CSSStyleSheetResource(request, charset);
-    case Resource::Script:
-        return ScriptResource::create(request, charset).leakPtr();
-    case Resource::SVGDocument:
-        return new DocumentResource(request, Resource::SVGDocument);
-    case Resource::Font:
-        return new FontResource(request);
-    case Resource::MainResource:
-    case Resource::Raw:
-    case Resource::TextTrack:
-    case Resource::Media:
-        return new RawResource(request, type);
-    case Resource::XSLStyleSheet:
-        return new XSLStyleSheetResource(request, charset);
-    case Resource::LinkPrefetch:
-        return new Resource(request, Resource::LinkPrefetch);
-    case Resource::LinkSubresource:
-        return new Resource(request, Resource::LinkSubresource);
-    case Resource::LinkPreload:
-        return new Resource(request, Resource::LinkPreload);
-    case Resource::ImportResource:
-        return new RawResource(request, type);
-    }
-
-    ASSERT_NOT_REACHED();
-    return 0;
-}
-
 ResourceLoadPriority ResourceFetcher::loadPriority(Resource::Type type, const FetchRequest& request)
 {
     // TODO(yoav): Change it here so that priority can be changed even after it was resolved.
     if (request.priority() != ResourceLoadPriorityUnresolved)
         return request.priority();
 
     switch (type) {
     case Resource::MainResource:
         return ResourceLoadPriorityVeryHigh;
     case Resource::CSSStyleSheet:
@@ skipping 25 matching lines @@
         return ResourceLoadPriorityVeryLow;
     case Resource::LinkSubresource:
         return ResourceLoadPriorityLow;
     case Resource::TextTrack:
         return ResourceLoadPriorityLow;
     }
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
-static Resource* resourceFromDataURIRequest(const ResourceRequest& request, const ResourceLoaderOptions& resourceOptions, const String& cacheIdentifier)
-{
-    const KURL& url = request.url();
-    ASSERT(url.protocolIsData());
-
-    WebString mimetype;
-    WebString charset;
-    RefPtr<SharedBuffer> data = PassRefPtr<SharedBuffer>(Platform::current()->parseDataURL(url, mimetype, charset));
-    if (!data)
-        return nullptr;
-    ResourceResponse response(url, mimetype, data->size(), charset, String());
-
-    Resource* resource = createResource(Resource::Image, request, charset);
-    resource->setOptions(resourceOptions);
-    // FIXME: We should provide a body stream here.
-    resource->responseReceived(response, nullptr);
-    if (data->size())
-        resource->setResourceBuffer(data);
-    resource->setCacheIdentifier(cacheIdentifier);
-    resource->finish();
-    return resource;
-}
-
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
 {
     info->setInitialRequest(resource->resourceRequest());
     info->setFinalResponse(resource->response());
     if (clearLoadTimings) {
         info->clearLoadTimings();
         info->setLoadFinishTime(info->initialTime());
     } else {
         info->setLoadFinishTime(resource->loadFinishTime());
     }
@@ skipping 61 matching lines @@
     ASSERT(!m_loaders || m_loaders->isEmpty());
 #endif
 }
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
     return m_documentResources.get(url).get();
 }
 
-ResourcePtr<Resource> ResourceFetcher::fetchSynchronously(FetchRequest& request)
-{
-    request.mutableResourceRequest().setTimeoutInterval(10);
-    ResourceLoaderOptions options(request.options());
-    options.synchronousPolicy = RequestSynchronously;
-    request.setOptions(options);
-    return requestResource(Resource::Raw, request);
-}
-
-ResourcePtr<ImageResource> ResourceFetcher::fetchImage(FetchRequest& request)
-{
-    if (request.resourceRequest().requestContext() == WebURLRequest::RequestContextUnspecified)
-        request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImage);
-    if (context().pageDismissalEventBeingDispatched()) {
-        KURL requestURL = request.resourceRequest().url();
-        if (requestURL.isValid() && context().canRequest(Resource::Image, request.resourceRequest(), requestURL, request.options(), request.forPreload(), request.originRestriction()))
-            context().sendImagePing(requestURL);
-        return 0;
-    }
-
-    if (request.resourceRequest().url().protocolIsData())
-        preCacheDataURIImage(request);
-
-    if (clientDefersImage(request.resourceRequest().url()))
-        request.setDefer(FetchRequest::DeferredByClient);
-    ResourcePtr<Resource> resource = requestResource(Resource::Image, request);
-    return resource && resource->type() == Resource::Image ? toImageResource(resource) : 0;
-}
-
-void ResourceFetcher::preCacheDataURIImage(const FetchRequest& request)
-{
-    const KURL& url = request.resourceRequest().url();
-    ASSERT(url.protocolIsData());
-
-    const String cacheIdentifier = getCacheIdentifier();
-    if (memoryCache()->resourceForURL(url, cacheIdentifier))
-        return;
-
-    if (Resource* resource = resourceFromDataURIRequest(request.resourceRequest(), request.options(), cacheIdentifier)) {
-        memoryCache()->add(resource);
-        scheduleDocumentResourcesGC();
-    }
-}
-
-ResourcePtr<FontResource> ResourceFetcher::fetchFont(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextFont);
-    return toFontResource(requestResource(Resource::Font, request));
-}
-
-ResourcePtr<RawResource> ResourceFetcher::fetchImport(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImport);
-    return toRawResource(requestResource(Resource::ImportResource, request));
-}
-
-ResourcePtr<CSSStyleSheetResource> ResourceFetcher::fetchCSSStyleSheet(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextStyle);
-    return toCSSStyleSheetResource(requestResource(Resource::CSSStyleSheet, request));
-}
-
-ResourcePtr<ScriptResource> ResourceFetcher::fetchScript(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextScript);
-    return toScriptResource(requestResource(Resource::Script, request));
-}
-
-ResourcePtr<XSLStyleSheetResource> ResourceFetcher::fetchXSLStyleSheet(FetchRequest& request)
-{
-    ASSERT(RuntimeEnabledFeatures::xsltEnabled());
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextXSLT);
-    return toXSLStyleSheetResource(requestResource(Resource::XSLStyleSheet, request));
-}
-
-ResourcePtr<DocumentResource> ResourceFetcher::fetchSVGDocument(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextImage);
-    return toDocumentResource(requestResource(Resource::SVGDocument, request));
-}
-
-ResourcePtr<Resource> ResourceFetcher::fetchLinkResource(Resource::Type type, FetchRequest& request)
-{
-    ASSERT(type == Resource::LinkPrefetch || type == Resource::LinkSubresource);
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(type == Resource::LinkPrefetch ? WebURLRequest::RequestContextPrefetch : WebURLRequest::RequestContextSubresource);
-    return requestResource(type, request);
-}
-
-ResourcePtr<Resource> ResourceFetcher::fetchLinkPreloadResource(Resource::Type type, FetchRequest& request)
-{
-    // TODO(yoav): Enforce a LinkPreload context here, once we know we're adding one - https://github.com/whatwg/fetch/issues/36
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    determineRequestContext(request.mutableResourceRequest(), type);
-    return requestResource(type, request);
-}
-
-ResourcePtr<RawResource> ResourceFetcher::fetchRawResource(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    ASSERT(request.resourceRequest().requestContext() != WebURLRequest::RequestContextUnspecified);
-    return toRawResource(requestResource(Resource::Raw, request));
-}
-
-ResourcePtr<RawResource> ResourceFetcher::fetchMainResource(FetchRequest& request, const SubstituteData& substituteData)
-{
-    ASSERT(request.resourceRequest().frameType() != WebURLRequest::FrameTypeNone);
-    ASSERT(request.resourceRequest().requestContext() == WebURLRequest::RequestContextForm || request.resourceRequest().requestContext() == WebURLRequest::RequestContextFrame || request.resourceRequest().requestContext() == WebURLRequest::RequestContextHyperlink || request.resourceRequest().requestContext() == WebURLRequest::RequestContextIframe || request.resourceRequest().requestContext() == WebURLRequest::RequestContextInternal || request.resourceRequest().requestContext() == WebURLRequest::RequestContextLocation);
-
-    if (substituteData.isValid())
-        preCacheSubstituteDataForMainResource(request, substituteData);
-    return toRawResource(requestResource(Resource::MainResource, request));
-}
-
-ResourcePtr<RawResource> ResourceFetcher::fetchMedia(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    ASSERT(request.resourceRequest().requestContext() == WebURLRequest::RequestContextAudio || request.resourceRequest().requestContext() == WebURLRequest::RequestContextVideo);
-    return toRawResource(requestResource(Resource::Media, request));
-}
-
-ResourcePtr<RawResource> ResourceFetcher::fetchTextTrack(FetchRequest& request)
-{
-    ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
-    request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextTrack);
-    return toRawResource(requestResource(Resource::TextTrack, request));
-}
-
-void ResourceFetcher::preCacheSubstituteDataForMainResource(const FetchRequest& request, const SubstituteData& substituteData)
-{
-    const String cacheIdentifier = getCacheIdentifier();
-    const KURL& url = request.url();
-    if (Resource* oldResource = memoryCache()->resourceForURL(url, cacheIdentifier))
-        memoryCache()->remove(oldResource);
-
-    ResourceResponse response(url, substituteData.mimeType(), substituteData.content()->size(), substituteData.textEncoding(), emptyString());
-    ResourcePtr<Resource> resource = createResource(Resource::MainResource, request.resourceRequest(), substituteData.textEncoding());
-    resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
-    resource->setOptions(request.options());
-    resource->setDataBufferingPolicy(BufferData);
-    resource->responseReceived(response, nullptr);
-    if (substituteData.content()->size())
-        resource->setResourceBuffer(substituteData.content());
-    resource->setCacheIdentifier(cacheIdentifier);
-    resource->finish();
-    memoryCache()->add(resource.get());
-}
-
 bool ResourceFetcher::canAccessResource(Resource* resource, SecurityOrigin* sourceOrigin, const KURL& url, AccessControlLoggingDecision logErrorsDecision) const
 {
     // Redirects can change the response URL different from one of request.
     bool forPreload = resource->isUnusedPreload();
     if (!context().canRequest(resource->type(), resource->resourceRequest(), url, resource->options(), forPreload, FetchRequest::UseDefaultOriginRestrictionForType))
         return false;
 
     if (!sourceOrigin)
         sourceOrigin = context().securityOrigin();
 
     if (sourceOrigin->canRequest(url))
         return true;
 
     String errorDescription;
     if (!resource->passesAccessControlCheck(sourceOrigin, errorDescription)) {
-        if (resource->type() == Resource::Font)
-            toFontResource(resource)->setCORSFailed();
+        resource->setCORSFailed();
         if (!forPreload && (logErrorsDecision == ShouldLogAccessControlErrors)) {
             String resourceType = Resource::resourceTypeToString(resource->type(), resource->options().initiatorInfo);
             context().addConsoleMessage(resourceType + " from origin '" + SecurityOrigin::create(url)->toString() + "' has been blocked from loading by Cross-Origin Resource Sharing policy: " + errorDescription);
         }
         return false;
     }
     return true;
 }
 
 bool ResourceFetcher::isControlledByServiceWorker() const
@@ skipping 32 matching lines @@
         if (!m_resourceTimingReportTimer.isActive())
             m_resourceTimingReportTimer.startOneShot(0, FROM_HERE);
     }
 
     if (m_validatedURLs.size() >= kMaxValidatedURLsSize) {
         m_validatedURLs.clear();
     }
     m_validatedURLs.add(request.resourceRequest().url());
 }
 
-ResourcePtr<Resource> ResourceFetcher::requestResource(Resource::Type type, FetchRequest& request)
+ResourcePtr<Resource> ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory)
 {
-    ASSERT(request.options().synchronousPolicy == RequestAsynchronously || type == Resource::Raw);
+    ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw);
 
     TRACE_EVENT0("blink", "ResourceFetcher::requestResource");
 
     context().upgradeInsecureRequest(request);
     context().addClientHintsIfNecessary(request);
-    context().addCSPHeaderIfNecessary(type, request);
+    context().addCSPHeaderIfNecessary(factory.type(), request);
 
     KURL url = request.resourceRequest().url();
 
-    WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, forPreload=%u, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload(), ResourceTypeName(type));
+    WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, forPreload=%u, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload(), ResourceTypeName(factory.type()));
 
     // If only the fragment identifiers differ, it is the same resource.
     url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
 
     if (!url.isValid())
         return nullptr;
 
-    if (!context().canRequest(type, request.resourceRequest(), url, request.options(), request.forPreload(), request.originRestriction()))
+    if (!context().canRequest(factory.type(), request.resourceRequest(), url, request.options(), request.forPreload(), request.originRestriction()))
         return nullptr;
 
     context().dispatchWillRequestResource(&request);
 
     if (!request.forPreload()) {
         V8DOMActivityLogger* activityLogger = nullptr;
         if (request.options().initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest)
             activityLogger = V8DOMActivityLogger::currentActivityLogger();
         else
             activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 
         if (activityLogger) {
             Vector<String> argv;
-            argv.append(Resource::resourceTypeToString(type, request.options().initiatorInfo));
+            argv.append(Resource::resourceTypeToString(factory.type(), request.options().initiatorInfo));
             argv.append(url);
             activityLogger->logEvent("blinkRequestResource", argv.size(), argv.data());
         }
     }
 
     // See if we can use an existing resource from the cache.
     ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url, getCacheIdentifier());
 
-    const RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
+    const RevalidationPolicy policy = determineRevalidationPolicy(factory.type(), request, resource.get());
     switch (policy) {
     case Reload:
         memoryCache()->remove(resource.get());
         // Fall through
     case Load:
-        resource = createResourceForLoading(type, request, request.charset());
+        resource = createResourceForLoading(request, request.charset(), factory);
         break;
     case Revalidate:
-        resource = createResourceForRevalidation(request, resource.get());
+        resource = createResourceForRevalidation(request, resource.get(), factory);
         break;
     case Use:
         memoryCache()->updateForAccess(resource.get());
         break;
     }
 
     if (!resource)
         return nullptr;
+    if (resource->type() != factory.type()) {
+        ASSERT(request.forPreload());
+        return nullptr;
+    }
 
     if (!resource->hasClients())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
         resource->setIdentifier(createUniqueIdentifier());
 
     if (!request.forPreload() || policy != Use) {
-        ResourceLoadPriority priority = loadPriority(type, request);
+        ResourceLoadPriority priority = loadPriority(factory.type(), request);
         // When issuing another request for a resource that is already in-flight make
         // sure to not demote the priority of the in-flight request. If the new request
         // isn't at the same priority as the in-flight request, only allow promotions.
         // This can happen when a visible image's priority is increased and then another
         // reference to the image is parsed (which would be at a lower priority).
         if (priority > resource->resourceRequest().priority()) {
             resource->mutableResourceRequest().setPriority(priority);
             resource->didChangePriority(priority, 0);
         }
     }
 
     if (resourceNeedsLoad(resource.get(), request, policy)) {
-        if (!context().shouldLoadNewResource(type)) {
+        if (!context().shouldLoadNewResource(factory.type())) {
             if (memoryCache()->contains(resource.get()))
                 memoryCache()->remove(resource.get());
             return nullptr;
         }
 
         if (!scheduleArchiveLoad(resource.get(), request.resourceRequest()))
             resource->load(this, request.options());
 
         // For asynchronous loads that immediately fail, it's sufficient to return a
         // null Resource, as it indicates that something prevented the load from starting.
         // If there's a network error, that failure will happen asynchronously. However, if
         // a sync load receives a network error, it will have already happened by this point.
         // In that case, the requester should have access to the relevant ResourceError, so
         // we need to return a non-null Resource.
         if (resource->errorOccurred()) {
             if (memoryCache()->contains(resource.get()))
                 memoryCache()->remove(resource.get());
             return request.options().synchronousPolicy == RequestSynchronously ? resource : nullptr;
         }
     }
 
     // FIXME: Temporarily leave main resource caching disabled for chromium,
     // see https://bugs.webkit.org/show_bug.cgi?id=107962. Before caching main
     // resources, we should be sure to understand the implications for memory
     // use.
     // Remove main resource from cache to prevent reuse.
-    if (type == Resource::MainResource) {
+    if (factory.type() == Resource::MainResource) {
         ASSERT(policy != Use || context().hasSubstituteData());
         ASSERT(policy != Revalidate);
         memoryCache()->remove(resource.get());
     }
 
     requestLoadStarted(resource.get(), request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork);
 
     ASSERT(resource->url() == url.string());
     m_documentResources.set(resource->url(), resource);
     return resource;
@@ skipping 19 matching lines @@
     if (request.cachePolicy() == UseProtocolCachePolicy)
         request.setCachePolicy(context().resourceRequestCachePolicy(request, type));
     if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
         determineRequestContext(request, type);
     if (type == Resource::LinkPrefetch || type == Resource::LinkSubresource)
         request.setHTTPHeaderField("Purpose", "prefetch");
 
     context().addAdditionalRequestHeaders(request, (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
-ResourcePtr<Resource> ResourceFetcher::createResourceForRevalidation(const FetchRequest& request, Resource* resource)
+ResourcePtr<Resource> ResourceFetcher::createResourceForRevalidation(const FetchRequest& request, Resource* resource, const ResourceFactory& factory)
 {
     ASSERT(resource);
     ASSERT(memoryCache()->contains(resource));
     ASSERT(resource->isLoaded());
     ASSERT(resource->canUseCacheValidator());
     ASSERT(!resource->resourceToRevalidate());
     ASSERT(!context().isControlledByServiceWorker());
 
     ResourceRequest revalidatingRequest(resource->resourceRequest());
     revalidatingRequest.clearHTTPReferrer();
     addAdditionalRequestHeaders(revalidatingRequest, resource->type());
 
     const AtomicString& lastModified = resource->response().httpHeaderField("Last-Modified");
     const AtomicString& eTag = resource->response().httpHeaderField("ETag");
     if (!lastModified.isEmpty() || !eTag.isEmpty()) {
         ASSERT(context().cachePolicy() != CachePolicyReload);
         if (context().cachePolicy() == CachePolicyRevalidate)
             revalidatingRequest.setHTTPHeaderField("Cache-Control", "max-age=0");
     }
     if (!lastModified.isEmpty())
         revalidatingRequest.setHTTPHeaderField("If-Modified-Since", lastModified);
     if (!eTag.isEmpty())
         revalidatingRequest.setHTTPHeaderField("If-None-Match", eTag);
 
     double stalenessLifetime = resource->stalenessLifetime();
     if (std::isfinite(stalenessLifetime) && stalenessLifetime > 0) {
         revalidatingRequest.setHTTPHeaderField("Resource-Freshness", AtomicString(String::format("max-age=%.0lf,stale-while-revalidate=%.0lf,age=%.0lf", resource->freshnessLifetime(), stalenessLifetime, resource->currentAge())));
     }
 
-    ResourcePtr<Resource> newResource = createResource(resource->type(), revalidatingRequest, resource->encoding());
+    ResourcePtr<Resource> newResource = factory.create(revalidatingRequest, resource->encoding());
     WTF_LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
 
     newResource->setResourceToRevalidate(resource);
     newResource->setCacheIdentifier(resource->cacheIdentifier());
 
     memoryCache()->remove(resource);
     memoryCache()->add(newResource.get());
     return newResource;
 }
 
-ResourcePtr<Resource> ResourceFetcher::createResourceForLoading(Resource::Type type, FetchRequest& request, const String& charset)
+ResourcePtr<Resource> ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
 {
     const String cacheIdentifier = getCacheIdentifier();
     ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
 
     WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
 
-    addAdditionalRequestHeaders(request.mutableResourceRequest(), type);
-    ResourcePtr<Resource> resource = createResource(type, request.resourceRequest(), charset);
+    addAdditionalRequestHeaders(request.mutableResourceRequest(), factory.type());
+    ResourcePtr<Resource> resource = factory.create(request.resourceRequest(), charset);
     resource->setCacheIdentifier(cacheIdentifier);
 
     memoryCache()->add(resource.get());
     return resource;
 }
 
 void ResourceFetcher::storeResourceTimingInitiatorInformation(Resource* resource)
 {
     if (resource->options().requestInitiatorContext != DocumentContext)
         return;
@@ skipping 247 matching lines @@
     // FIXME: If willSendRequest changes the request, we don't respect it.
     willSendRequest(identifier, request, ResourceResponse(), resource->options().initiatorInfo);
     context().sendRemainingDelegateMessages(identifier, resource->response(), resource->encodedSize());
 }
 
 int ResourceFetcher::requestCount() const
 {
     return m_loaders ? m_loaders->size() : 0;
 }
 
-void ResourceFetcher::preload(Resource::Type type, FetchRequest& request, const String& charset)
+void ResourceFetcher::preloadStarted(Resource* resource)
 {
-    // Ensure main resources aren't preloaded, since the cache can't actually reuse the preload.
-    if (type == Resource::MainResource)
+    if (m_preloads && m_preloads->contains(resource))
         return;
-
-    ASSERT(type == Resource::Script || type == Resource::CSSStyleSheet || type == Resource::Image);
-
-    String encoding;
-    if (type == Resource::Script || type == Resource::CSSStyleSheet) {
-        encoding = charset.isEmpty() ? context().charset() : charset;
-
-        // RequestContext for Resource::Image is set in fetchImage below.
-        determineRequestContext(request.mutableResourceRequest(), type);
-    }
-
-    request.setCharset(encoding);
-    request.setForPreload(true);
-
-    ResourcePtr<Resource> resource;
-    // Loading images involves several special cases, so use dedicated fetch method instead.
-    if (type == Resource::Image)
-        resource = fetchImage(request);
-    else
-        resource = requestResource(type, request);
-    if (!resource || (m_preloads && m_preloads->contains(resource.get())))
-        return;
-    TRACE_EVENT_ASYNC_STEP_INTO0("blink.net", "Resource", resource.get(), "Preload");
+    TRACE_EVENT_ASYNC_STEP_INTO0("blink.net", "Resource", resource, "Preload");
     resource->increasePreloadCount();
 
     if (!m_preloads)
         m_preloads = adoptPtr(new ListHashSet<Resource*>);
-    m_preloads->add(resource.get());
+    m_preloads->add(resource);
 
 #if PRELOAD_DEBUG
     printf("PRELOADING %s\n",  resource->url().string().latin1().data());
 #endif
 }
 
 bool ResourceFetcher::isPreloaded(const KURL& url) const
 {
     if (m_preloads) {
         for (Resource* resource : *m_preloads) {
@@ skipping 194 matching lines @@
     if (!context().canRequest(resource->type(), request, request.url(), options, resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
         return false;
     if (options.corsEnabled == IsCORSEnabled) {
         SecurityOrigin* sourceOrigin = options.securityOrigin.get();
         if (!sourceOrigin)
             sourceOrigin = context().securityOrigin();
 
         String errorMessage;
         StoredCredentials withCredentials = resource->lastResourceRequest().allowStoredCredentials() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
         if (!CrossOriginAccessControl::handleRedirect(sourceOrigin, request, redirectResponse, withCredentials, options, errorMessage)) {
-            if (resource->type() == Resource::Font)
-                toFontResource(resource)->setCORSFailed();
+            resource->setCORSFailed();
             context().addConsoleMessage(errorMessage);
             return false;
         }
     }
     if (resource->type() == Resource::Image && shouldDeferImageLoad(request.url()))
         return false;
     return true;
 }
 
 #if PRELOAD_DEBUG
@@ skipping 94 matching lines @@
 
 DEFINE_TRACE(ResourceFetcher)
 {
     visitor->trace(m_context);
     visitor->trace(m_archiveResourceCollection);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
 }
 
 }