Prefetch @import files from CSS files.

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 55 matching lines @@
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURL.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
 #define PRELOAD_DEBUG 0
 
 namespace WebCore {
 
-static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
+static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset, Document* document)
 {
     switch (type) {
     case Resource::Image:
         return new ImageResource(request);
     case Resource::CSSStyleSheet:
-        return new CSSStyleSheetResource(request, charset);
+        return new CSSStyleSheetResource(request, charset, document);
     case Resource::Script:
         return new ScriptResource(request, charset);
     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:
         return new RawResource(request, type);
@@ skipping 56 matching lines @@
     const KURL& url = request.url();
     ASSERT(url.protocolIsData());
 
     blink::WebString mimetype;
     blink::WebString charset;
     RefPtr<SharedBuffer> data = PassRefPtr<SharedBuffer>(blink::Platform::current()->parseDataURL(url, mimetype, charset));
     if (!data)
         return 0;
     ResourceResponse response(url, mimetype, data->size(), charset, String());
 
-    Resource* resource = createResource(Resource::Image, request, charset);
+    Resource* resource = createResource(Resource::Image, request, charset, 0);
     resource->setOptions(resourceOptions);
     resource->responseReceived(response);
     if (data->size())
         resource->setResourceBuffer(data);
     resource->finish();
     return resource;
 }
 
 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
 {
@@ skipping 206 matching lines @@
     return toRawResource(requestResource(Resource::MainResource, request));
 }
 
 void ResourceFetcher::preCacheSubstituteDataForMainResource(const FetchRequest& request, const SubstituteData& substituteData)
 {
     const KURL& url = request.url();
     if (Resource* oldResource = memoryCache()->resourceForURL(url))
         memoryCache()->remove(oldResource);
 
     ResourceResponse response(url, substituteData.mimeType(), substituteData.content()->size(), substituteData.textEncoding(), emptyString());
-    ResourcePtr<Resource> resource = createResource(Resource::MainResource, request.resourceRequest(), substituteData.textEncoding());
+    ResourcePtr<Resource> resource = createResource(Resource::MainResource, request.resourceRequest(), substituteData.textEncoding(), document());
     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
     resource->setOptions(request.options());
     resource->setDataBufferingPolicy(BufferData);
     resource->responseReceived(response);
     if (substituteData.content()->size())
         resource->setResourceBuffer(substituteData.content());
     resource->finish();
     memoryCache()->add(resource.get());
 }
 
@@ skipping 392 matching lines @@
     if (!lastModified.isEmpty() || !eTag.isEmpty()) {
         ASSERT(context().cachePolicy(document()) != CachePolicyReload);
         if (context().cachePolicy(document()) == 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);
     }
 
-    ResourcePtr<Resource> newResource = createResource(resource->type(), revalidatingRequest, resource->encoding());
+    ResourcePtr<Resource> newResource = createResource(resource->type(), revalidatingRequest, resource->encoding(), document());
 
     WTF_LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
     newResource->setResourceToRevalidate(resource);
 
     memoryCache()->remove(resource);
     memoryCache()->add(newResource.get());
     storeResourceTimingInitiatorInformation(newResource, request);
     TRACE_EVENT_ASYNC_BEGIN2("net", "Resource", newResource.get(), "url", newResource->url().string().ascii(), "priority", newResource->resourceRequest().priority());
     return newResource;
 }
 
 ResourcePtr<Resource> ResourceFetcher::loadResource(Resource::Type type, FetchRequest& request, const String& charset)
 {
     ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url()));
 
     WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
 
     addAdditionalRequestHeaders(request.mutableResourceRequest(), type);
-    ResourcePtr<Resource> resource = createResource(type, request.mutableResourceRequest(), charset);
+    ResourcePtr<Resource> resource = createResource(type, request.mutableResourceRequest(), charset, document());
 
     memoryCache()->add(resource.get());
     storeResourceTimingInitiatorInformation(resource, request);
     TRACE_EVENT_ASYNC_BEGIN2("net", "Resource", resource.get(), "url", resource->url().string().ascii(), "priority", resource->resourceRequest().priority());
     return resource;
 }
 
 void ResourceFetcher::storeResourceTimingInitiatorInformation(const ResourcePtr<Resource>& resource, const FetchRequest& request)
 {
     if (request.options().requestInitiatorContext != DocumentContext)
@@ skipping 572 matching lines @@
     case Revalidate:
         ++m_revalidateCount;
         return;
     case Use:
         ++m_useCount;
         return;
     }
 }
 
 }