170     Resource* resource = createResource(Resource::Image, request, charset);
171     resource->setOptions(resourceOptions);
172     resource->responseReceived(response);
174         resource->setResourceBuffer(data);
175     resource->finish();
176     return resource;
179 static void populateResourceTiming(ResourceTimingInfo* info, Resource* resource, bool clearLoadTimings)
181     info->setInitialRequest(resource->resourceRequest());
182     info->setFinalResponse(resource->response());
187         info->setLoadFinishTime(resource->loadFinishTime());
323     ResourcePtr<Resource> resource = requestResource(Resource::Image, request);
324     return resource && resource->type() == Resource::Image ? toImageResource(resource) : 0;
335     if (Resource* resource = resourceFromDataURIRequest(request.resourceRequest(), request.options())) {
336         memoryCache()->add(resource);
431     ResourcePtr<Resource> resource = createResource(Resource::MainResource, request.resourceRequest(), substituteData.textEncoding());
432     resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
433     resource->setOptions(request.options());
434     resource->setDataBufferingPolicy(BufferData);
435     resource->responseReceived(response);
437         resource->setResourceBuffer(substituteData.content());
438     resource->finish();
439     memoryCache()->add(resource.get());
573     // If we're loading the main resource of a subframe, ensure that we check
585 bool ResourceFetcher::canAccessResource(Resource* resource, SecurityOrigin* sourceOrigin, const KURL& url) const
588     if (!canRequest(resource->type(), resource->resourceRequest(), url, resource->options(), resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
598     if (!resource->passesAccessControlCheck(sourceOrigin, errorDescription)) {
599         if (resource->type() == Resource::Font)
600             toFontResource(resource)->setCORSFailed();
602             String resourceType = Resource::resourceTypeToString(resource->type(), resource->options().initiatorInfo);
621 bool ResourceFetcher::resourceNeedsLoad(Resource* resource, const FetchRequest& request, RevalidationPolicy policy)
627     if (resource->stillNeedsLoad())
629     return request.options().synchronousPolicy == RequestSynchronously && resource->isLoading();
632 void ResourceFetcher::requestLoadStarted(Resource* resource, const FetchRequest& request, ResourceLoadStartType type)
635         notifyLoadedFromMemoryCache(resource);
640     if (type == ResourceLoadingFromCache && !resource->stillNeedsLoad() && !m_validatedURLs.contains(request.resourceRequest().url())) {
643         populateResourceTiming(info.get(), resource, true);
644         m_scheduledResourceTimingReports.add(info, resource->type() == Resource::MainResource);
662     // If only the fragment identifiers differ, it is the same resource.
689     // See if we can use an existing resource from the cache.
690     ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url);
692     const RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
695         memoryCache()->remove(resource.get());
698         resource = createResourceForLoading(type, request, request.charset());
701         resource = createResourceForRevalidation(request, resource.get());
704         memoryCache()->updateForAccess(resource.get());
708     if (!resource)
711     if (!resource->hasClients())
715         resource->setIdentifier(createUniqueIdentifier());
719         if (priority != resource->resourceRequest().priority()) {
720             resource->mutableResourceRequest().setPriority(priority);
721             resource->didChangePriority(priority, 0);
725     if (resourceNeedsLoad(resource.get(), request, policy)) {
727             if (memoryCache()->contains(resource.get()))
728                 memoryCache()->remove(resource.get());
732         if (!m_documentLoader || !m_documentLoader->scheduleArchiveLoad(resource.get(), request.resourceRequest()))
733             resource->load(this, request.options());
741         if (resource->errorOccurred()) {
742             if (memoryCache()->contains(resource.get()))
743                 memoryCache()->remove(resource.get());
744             return request.options().synchronousPolicy == RequestSynchronously ? resource : 0;
748     // FIXME: Temporarily leave main resource caching disabled for chromium,
752     // Remove main resource from cache to prevent reuse.
756         memoryCache()->remove(resource.get());
759     requestLoadStarted(resource.get(), request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork);
761     ASSERT(resource->url() == url.string());
762     m_documentResources.set(resource->url(), resource);
763     return resource;
807         // For POST requests, we mutate the main resource's cache policy to avoid form resubmission.
835 ResourcePtr<Resource> ResourceFetcher::createResourceForRevalidation(const FetchRequest& request, Resource* resource)
837     ASSERT(resource);
838     ASSERT(memoryCache()->contains(resource));
839     ASSERT(resource->isLoaded());
840     ASSERT(resource->canUseCacheValidator());
841     ASSERT(!resource->resourceToRevalidate());
843     ResourceRequest revalidatingRequest(resource->resourceRequest());
845     addAdditionalRequestHeaders(revalidatingRequest, resource->type());
847     const AtomicString& lastModified = resource->response().httpHeaderField("Last-Modified");
848     const AtomicString& eTag = resource->response().httpHeaderField("ETag");
859     ResourcePtr<Resource> newResource = createResource(resource->type(), revalidatingRequest, resource->encoding());
860     WTF_LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
862     newResource->setResourceToRevalidate(resource);
864     memoryCache()->remove(resource);
876     ResourcePtr<Resource> resource = createResource(type, request.resourceRequest(), charset);
878     memoryCache()->add(resource.get());
879     return resource;
882 void ResourceFetcher::storeResourceTimingInitiatorInformation(Resource* resource)
884     if (resource->options().requestInitiatorContext != DocumentContext)
887     RefPtr<ResourceTimingInfo> info = ResourceTimingInfo::create(resource->options().initiatorInfo.name, monotonicallyIncreasingTime());
889     if (resource->isCacheValidator()) {
890         const AtomicString& timingAllowOrigin = resource->resourceToRevalidate()->response().httpHeaderField("Timing-Allow-Origin");
895     if (resource->type() == Resource::MainResource) {
900             m_resourceTimingInfoMap.add(resource, info);
904         m_resourceTimingInfoMap.add(resource, info);
939     // If a main resource was populated from a SubstituteData load, use it.
946     // Never use cache entries for downloadToFile requests. The caller expects the resource in a file.
979     // with this one, or vice versa, re-fetch the resource.
989     // During the initial load, avoid loading the same resource multiple times for a single document,
991     // We also group loads of the same resource together.
1007     // We'll try to reload the resource if it failed last time.
1009         WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicye reloading due to resource being in the error state");
1018     // If any of the redirects in the chain to loading the resource were not cacheable, we cannot reuse our cached resource.
1027         // See if the resource has usable ETag or Last-modified headers.
1096         Resource* resource = it->value.get();
1097         if (resource->type() == Resource::Image && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
1098             const_cast<Resource*>(resource)->load(this, defaultResourceOptions());
1102 void ResourceFetcher::redirectReceived(Resource* resource, const ResourceResponse& redirectResponse)
1104     ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
1109 void ResourceFetcher::didLoadResource(Resource* resource)
1114     if (resource && resource->response().isHTTP() && ((!resource->errorOccurred() && !resource->wasCanceled()) || resource->response().httpStatusCode() == 304) && document()) {
1115         ResourceTimingInfoMap::iterator it = m_resourceTimingInfoMap.find(resource);
1119             populateResourceTiming(info.get(), resource, false);
1120             reportResourceTiming(info.get(), document(), resource->type() == Resource::MainResource);
1160 void ResourceFetcher::notifyLoadedFromMemoryCache(Resource* resource)
1162     if (!frame() || !frame()->page() || resource->status() != Resource::Cached || m_validatedURLs.contains(resource->url()))
1165     ResourceRequest request(resource->url());
1167     context().dispatchDidLoadResourceFromMemoryCache(request, resource->response());
1169     willSendRequest(identifier, request, ResourceResponse(), resource->options().initiatorInfo);
1171     context().sendRemainingDelegateMessages(m_documentLoader, identifier, resource->response(), resource->encodedSize());
1209     ResourcePtr<Resource> resource;
1212         resource = fetchImage(request);
1213     if (!resource)
1214         resource = requestResource(type, request);
1215     if (!resource || (m_preloads && m_preloads->contains(resource.get())))
1217     TRACE_EVENT_ASYNC_STEP_INTO0("net", "Resource", resource.get(), "Preload");
1218     resource->increasePreloadCount();
1222     m_preloads->add(resource.get());
1225     printf("PRELOADING %s\n",  resource->url().string().latin1().data());
1236             Resource* resource = *it;
1237             if (resource->url() == url)
1264 void ResourceFetcher::didFinishLoading(const Resource* resource, double finishTime, int64_t encodedDataLength)
1266     TRACE_EVENT_ASYNC_END0("net", "Resource", resource);
1267     context().dispatchDidFinishLoading(m_documentLoader, resource->identifier(), finishTime, encodedDataLength);
1270 void ResourceFetcher::didChangeLoadingPriority(const Resource* resource, ResourceLoadPriority loadPriority, int intraPriorityValue)
1272     TRACE_EVENT_ASYNC_STEP_INTO1("net", "Resource", resource, "ChangePriority", "priority", loadPriority);
1273     context().dispatchDidChangeResourcePriority(resource->identifier(), loadPriority, intraPriorityValue);
1276 void ResourceFetcher::didFailLoading(const Resource* resource, const ResourceError& error)
1278     TRACE_EVENT_ASYNC_END0("net", "Resource", resource);
1279     context().dispatchDidFail(m_documentLoader, resource->identifier(), error);
1287 void ResourceFetcher::didReceiveResponse(const Resource* resource, const ResourceResponse& response)
1293         if (!canRequest(resource->type(), resource->resourceRequest(), response.url(), resource->options(), false, FetchRequest::UseDefaultOriginRestrictionForType)) {
1294             resource->loader()->cancel();
1295             context().dispatchDidFail(m_documentLoader, resource->identifier(), ResourceError(errorDomainBlinkInternal, 0, response.url().string(), "Unsafe attempt to load URL " + response.url().elidedString() + " fetched by a ServiceWorker."));
1299     context().dispatchDidReceiveResponse(m_documentLoader, resource->identifier(), response, resource->loader());
1302 void ResourceFetcher::didReceiveData(const Resource* resource, const char* data, int dataLength, int encodedDataLength)
1304     context().dispatchDidReceiveData(m_documentLoader, resource->identifier(), data, dataLength, encodedDataLength);
1307 void ResourceFetcher::didDownloadData(const Resource* resource, int dataLength, int encodedDataLength)
1309     context().dispatchDidDownloadData(m_documentLoader, resource->identifier(), dataLength, encodedDataLength);
1342 void ResourceFetcher::willStartLoadingResource(Resource* resource, ResourceRequest& request)
1347     storeResourceTimingInitiatorInformation(resource);
1348     TRACE_EVENT_ASYNC_BEGIN2("net", "Resource", resource, "url", resource->url().string().ascii(), "priority", resource->resourceRequest().priority());
1382 bool ResourceFetcher::canAccessRedirect(Resource* resource, ResourceRequest& request, const ResourceResponse& redirectResponse, ResourceLoaderOptions& options)
1384     if (!canRequest(resource->type(), request, request.url(), options, resource->isUnusedPreload(), FetchRequest::UseDefaultOriginRestrictionForType))
1392         if (!CrossOriginAccessControl::handleRedirect(resource, sourceOrigin, request, redirectResponse, options, errorMessage)) {
1393             if (resource->type() == Resource::Font)
1394                 toFontResource(resource)->setCORSFailed();
1400     if (resource->type() == Resource::Image && shouldDeferImageLoad(request.url()))

Indexes created Fri Mar 13 02:32:08 CET 2015