1 /*
2 Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
3 Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
4 Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
5 Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
6 Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
7
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public
10 License as published by the Free Software Foundation; either
11 version 2 of the License, or (at your option) any later version.
12
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Library General Public License for more details.
17
18 You should have received a copy of the GNU Library General Public License
19 along with this library; see the file COPYING.LIB. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA.
22
23 This class provides all functionality needed for loading images, style sheets and html
24 pages from the web. It has a memory cache for these objects.
25 */
26
27 #include "config.h"
28 #include "CachedResourceLoader.h"
29
30 #include "CachedCSSStyleSheet.h"
31 #include "CachedSVGDocument.h"
32 #include "CachedFont.h"
33 #include "CachedImage.h"
34 #include "CachedRawResource.h"
35 #include "CachedResourceRequest.h"
36 #include "CachedScript.h"
37 #include "CachedXSLStyleSheet.h"
38 #include "Console.h"
39 #include "ContentSecurityPolicy.h"
40 #include "DOMWindow.h"
41 #include "Document.h"
42 #include "DocumentLoader.h"
43 #include "Frame.h"
44 #include "FrameLoader.h"
45 #include "FrameLoaderClient.h"
46 #include "HTMLElement.h"
47 #include "HTMLFrameOwnerElement.h"
48 #include "LoaderStrategy.h"
49 #include "Logging.h"
50 #include "MemoryCache.h"
51 #include "PingLoader.h"
52 #include "PlatformStrategies.h"
53 #include "RenderElement.h"
54 #include "ResourceLoadScheduler.h"
55 #include "ScriptController.h"
56 #include "SecurityOrigin.h"
57 #include "Settings.h"
58 #include <wtf/text/CString.h>
59 #include <wtf/text/WTFString.h>
60
61 #if ENABLE(VIDEO_TRACK)
62 #include "CachedTextTrack.h"
63 #endif
64
65 #if ENABLE(RESOURCE_TIMING)
66 #include "Performance.h"
67 #endif
68
69 #define PRELOAD_DEBUG 0
70
71 namespace WebCore {
72
73 static CachedResource* createResource(CachedResource::Type type, ResourceRequest& request, const String& charset)
74 {
75 switch (type) {
76 case CachedResource::ImageResource:
77 return new CachedImage(request);
78 case CachedResource::CSSStyleSheet:
79 return new CachedCSSStyleSheet(request, charset);
80 case CachedResource::Script:
81 return new CachedScript(request, charset);
82 case CachedResource::SVGDocumentResource:
83 return new CachedSVGDocument(request);
84 case CachedResource::FontResource:
85 return new CachedFont(request);
86 case CachedResource::RawResource:
87 case CachedResource::MainResource:
88 return new CachedRawResource(request, type);
89 #if ENABLE(XSLT)
90 case CachedResource::XSLStyleSheet:
91 return new CachedXSLStyleSheet(request);
92 #endif
93 #if ENABLE(LINK_PREFETCH)
94 case CachedResource::LinkPrefetch:
95 return new CachedResource(request, CachedResource::LinkPrefetch);
96 case CachedResource::LinkSubresource:
97 return new CachedResource(request, CachedResource::LinkSubresource);
98 #endif
99 #if ENABLE(VIDEO_TRACK)
100 case CachedResource::TextTrackResource:
101 return new CachedTextTrack(request);
102 #endif
103 }
104 ASSERT_NOT_REACHED();
105 return 0;
106 }
107
108 CachedResourceLoader::CachedResourceLoader(DocumentLoader* documentLoader)
109 : m_document(0)
110 , m_documentLoader(documentLoader)
111 , m_requestCount(0)
112 , m_garbageCollectDocumentResourcesTimer(this, &CachedResourceLoader::garbageCollectDocumentResourcesTimerFired)
113 , m_autoLoadImages(true)
114 , m_imagesEnabled(true)
115 , m_allowStaleResources(false)
116 {
117 }
118
119 CachedResourceLoader::~CachedResourceLoader()
120 {
121 m_documentLoader = 0;
122 m_document = 0;
123
124 clearPreloads();
125 DocumentResourceMap::iterator end = m_documentResources.end();
126 for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it)
127 it->value->setOwningCachedResourceLoader(0);
128
129 // Make sure no requests still point to this CachedResourceLoader
130 ASSERT(m_requestCount == 0);
131 }
132
133 CachedResource* CachedResourceLoader::cachedResource(const String& resourceURL) const
134 {
135 URL url = m_document->completeURL(resourceURL);
136 return cachedResource(url);
137 }
138
139 CachedResource* CachedResourceLoader::cachedResource(const URL& resourceURL) const
140 {
141 URL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
142 return m_documentResources.get(url).get();
143 }
144
145 Frame* CachedResourceLoader::frame() const
146 {
147 return m_documentLoader ? m_documentLoader->frame() : 0;
148 }
149
150 CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
151 {
152 if (Frame* frame = this->frame()) {
153 if (frame->loader().pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) {
154 URL requestURL = request.resourceRequest().url();
155 if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL, request.options(), request.forPreload()))
156 PingLoader::loadImage(*frame, requestURL);
157 return nullptr;
158 }
159 }
160
161 request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
162 return toCachedImage(requestResource(CachedResource::ImageResource, request).get());
163 }
164
165 CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request)
166 {
167 return toCachedFont(requestResource(CachedResource::FontResource, request).get());
168 }
169
170 #if ENABLE(VIDEO_TRACK)
171 CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
172 {
173 return toCachedTextTrack(requestResource(CachedResource::TextTrackResource, request).get());
174 }
175 #endif
176
177 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(CachedResourceRequest& request)
178 {
179 return toCachedCSSStyleSheet(requestResource(CachedResource::CSSStyleSheet, request).get());
180 }
181
182 CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(CachedResourceRequest& request)
183 {
184 URL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.resourceRequest().url());
185
186 #if ENABLE(CACHE_PARTITIONING)
187 request.mutableResourceRequest().setCachePartition(document()->topOrigin()->cachePartition());
188 #endif
189
190 if (CachedResource* existing = memoryCache()->resourceForRequest(request.resourceRequest())) {
191 if (existing->type() == CachedResource::CSSStyleSheet)
192 return toCachedCSSStyleSheet(existing);
193 memoryCache()->remove(existing);
194 }
195 if (url.string() != request.resourceRequest().url())
196 request.mutableResourceRequest().setURL(url);
197
198 CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset());
199
200 memoryCache()->add(userSheet.get());
201 // FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?
202
203 userSheet->load(this, ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForAllCredentials, SkipSecurityCheck, UseDefaultOriginRestrictionsForType));
204
205 return userSheet;
206 }
207
208 CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(CachedResourceRequest& request)
209 {
210 return toCachedScript(requestResource(CachedResource::Script, request).get());
211 }
212
213 #if ENABLE(XSLT)
214 CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(CachedResourceRequest& request)
215 {
216 return toCachedXSLStyleSheet(requestResource(CachedResource::XSLStyleSheet, request).get());
217 }
218 #endif
219
220 CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(CachedResourceRequest& request)
221 {
222 return toCachedSVGDocument(requestResource(CachedResource::SVGDocumentResource, request).get());
223 }
224
225 #if ENABLE(LINK_PREFETCH)
226 CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, CachedResourceRequest& request)
227 {
228 ASSERT(frame());
229 ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkSubresource);
230 return requestResource(type, request);
231 }
232 #endif
233
234 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(CachedResourceRequest& request)
235 {
236 return toCachedRawResource(requestResource(CachedResource::RawResource, request).get());
237 }
238
239 CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestMainResource(CachedResourceRequest& request)
240 {
241 return toCachedRawResource(requestResource(CachedResource::MainResource, request).get());
242 }
243
244 bool CachedResourceLoader::checkInsecureContent(CachedResource::Type type, const URL& url) const
245 {
246 switch (type) {
247 case CachedResource::Script:
248 #if ENABLE(XSLT)
249 case CachedResource::XSLStyleSheet:
250 #endif
251 case CachedResource::SVGDocumentResource:
252 case CachedResource::CSSStyleSheet:
253 // These resource can inject script into the current document (Script,
254 // XSL) or exfiltrate the content of the current document (CSS).
255 if (Frame* f = frame())
256 if (!f->loader().mixedContentChecker().canRunInsecureContent(m_document->securityOrigin(), url))
257 return false;
258 break;
259 #if ENABLE(VIDEO_TRACK)
260 case CachedResource::TextTrackResource:
261 #endif
262 case CachedResource::RawResource:
263 case CachedResource::ImageResource:
264 case CachedResource::FontResource: {
265 // These resources can corrupt only the frame's pixels.
266 if (Frame* f = frame()) {
267 Frame& topFrame = f->tree().top();
268 if (!topFrame.loader().mixedContentChecker().canDisplayInsecureContent(topFrame.document()->securityOrigin(), url))
269 return false;
270 }
271 break;
272 }
273 case CachedResource::MainResource:
274 #if ENABLE(LINK_PREFETCH)
275 case CachedResource::LinkPrefetch:
276 case CachedResource::LinkSubresource:
277 // Prefetch cannot affect the current document.
278 #endif
279 break;
280 }
281 return true;
282 }
283
284 bool CachedResourceLoader::canRequest(CachedResource::Type type, const URL& url, const ResourceLoaderOptions& options, bool forPreload)
285 {
286 if (document() && !document()->securityOrigin()->canDisplay(url)) {
287 if (!forPreload)
288 FrameLoader::reportLocalLoadFailed(frame(), url.stringCenterEllipsizedToLength());
289 LOG(ResourceLoading, "CachedResourceLoader::requestResource URL was not allowed by SecurityOrigin::canDisplay");
290 return 0;
291 }
292
293 // FIXME: Convert this to check the isolated world's Content Security Policy once webkit.org/b/104520 is solved.
294 bool shouldBypassMainWorldContentSecurityPolicy = (frame() && frame()->script().shouldBypassMainWorldContentSecurityPolicy());
295
296 // Some types of resources can be loaded only from the same origin. Other
297 // types of resources, like Images, Scripts, and CSS, can be loaded from
298 // any URL.
299 switch (type) {
300 case CachedResource::MainResource:
301 case CachedResource::ImageResource:
302 case CachedResource::CSSStyleSheet:
303 case CachedResource::Script:
304 case CachedResource::FontResource:
305 case CachedResource::RawResource:
306 #if ENABLE(LINK_PREFETCH)
307 case CachedResource::LinkPrefetch:
308 case CachedResource::LinkSubresource:
309 #endif
310 #if ENABLE(VIDEO_TRACK)
311 case CachedResource::TextTrackResource:
312 #endif
313 if (options.requestOriginPolicy == RestrictToSameOrigin && !m_document->securityOrigin()->canRequest(url)) {
314 printAccessDeniedMessage(url);
315 return false;
316 }
317 break;
318 case CachedResource::SVGDocumentResource:
319 #if ENABLE(XSLT)
320 case CachedResource::XSLStyleSheet:
321 if (!m_document->securityOrigin()->canRequest(url)) {
322 printAccessDeniedMessage(url);
323 return false;
324 }
325 #endif
326 break;
327 }
328
329 switch (type) {
330 #if ENABLE(XSLT)
331 case CachedResource::XSLStyleSheet:
332 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowScriptFromSource(url))
333 return false;
334 break;
335 #endif
336 case CachedResource::Script:
337 #if PLATFORM(JAVA)
338 // m_document holds current active document loader
339 // if the cached resource doesn't belong to active document i.e these resource being requested from a older page
340 // which is about to be replaced by current active document loader
341 if (!m_document)
342 return false;
343 #endif
344 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowScriptFromSource(url))
345 return false;
346
347 if (frame()) {
348 if (!frame()->loader().client().allowScriptFromSource(frame()->settings().isScriptEnabled(), url))
349 return false;
350 }
351 break;
352 case CachedResource::CSSStyleSheet:
353 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowStyleFromSource(url))
354 return false;
355 break;
356 case CachedResource::SVGDocumentResource:
357 case CachedResource::ImageResource:
358 #if PLATFORM(JAVA)
359 if (!m_document)
360 return false;
361 #endif
362 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowImageFromSource(url))
363 return false;
364 break;
365 case CachedResource::FontResource: {
366 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowFontFromSource(url))
367 return false;
368 break;
369 }
370 case CachedResource::MainResource:
371 case CachedResource::RawResource:
372 #if ENABLE(LINK_PREFETCH)
373 case CachedResource::LinkPrefetch:
374 case CachedResource::LinkSubresource:
375 #endif
376 break;
377 #if ENABLE(VIDEO_TRACK)
378 case CachedResource::TextTrackResource:
379 if (!shouldBypassMainWorldContentSecurityPolicy && !m_document->contentSecurityPolicy()->allowMediaFromSource(url))
380 return false;
381 break;
382 #endif
383 }
384
385 // Last of all, check for insecure content. We do this last so that when
386 // folks block insecure content with a CSP policy, they don't get a warning.
387 // They'll still get a warning in the console about CSP blocking the load.
388
389 // FIXME: Should we consider forPreload here?
390 if (!checkInsecureContent(type, url))
391 return false;
392
393 return true;
394 }
395
396 bool CachedResourceLoader::shouldContinueAfterNotifyingLoadedFromMemoryCache(CachedResource* resource)
397 {
398 if (!resource || !frame() || resource->status() != CachedResource::Cached)
399 return true;
400
401 ResourceRequest newRequest;
402 frame()->loader().loadedResourceFromMemoryCache(resource, newRequest);
403
404 // FIXME <http://webkit.org/b/113251>: If the delegate modifies the request's
405 // URL, it is no longer appropriate to use this CachedResource.
406 return !newRequest.isNull();
407 }
408
409 CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest& request)
410 {
411 URL url = request.resourceRequest().url();
412
413 LOG(ResourceLoading, "CachedResourceLoader::requestResource '%s', charset '%s', priority=%d, forPreload=%u", url.stringCenterEllipsizedToLength().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload());
414
415 // If only the fragment identifiers differ, it is the same resource.
416 url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
417
418 if (!url.isValid())
419 return 0;
420
421 if (!canRequest(type, url, request.options(), request.forPreload()))
422 return 0;
423
424 if (Frame* f = frame())
425 f->loader().client().dispatchWillRequestResource(&request);
426
427 if (memoryCache()->disabled()) {
428 DocumentResourceMap::iterator it = m_documentResources.find(url.string());
429 if (it != m_documentResources.end()) {
430 it->value->setOwningCachedResourceLoader(0);
431 m_documentResources.remove(it);
432 }
433 }
434
435 // See if we can use an existing resource from the cache.
436 CachedResourceHandle<CachedResource> resource;
437 #if ENABLE(CACHE_PARTITIONING)
438 if (document())
439 request.mutableResourceRequest().setCachePartition(document()->topOrigin()->cachePartition());
440 #endif
441
442 resource = memoryCache()->resourceForRequest(request.resourceRequest());
443
444 const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
445 switch (policy) {
446 case Reload:
447 memoryCache()->remove(resource.get());
448 FALLTHROUGH;
449 case Load:
450 resource = loadResource(type, request, request.charset());
451 break;
452 case Revalidate:
453 resource = revalidateResource(request, resource.get());
454 break;
455 case Use:
456 if (!shouldContinueAfterNotifyingLoadedFromMemoryCache(resource.get()))
457 return 0;
458 memoryCache()->resourceAccessed(resource.get());
459 break;
460 }
461
462 if (!resource)
463 return 0;
464
465 if (!request.forPreload() || policy != Use)
466 resource->setLoadPriority(request.priority());
467
468 if ((policy != Use || resource->stillNeedsLoad()) && CachedResourceRequest::NoDefer == request.defer()) {
469 resource->load(this, request.options());
470
471 // We don't support immediate loads, but we do support immediate failure.
472 if (resource->errorOccurred()) {
473 if (resource->inCache())
474 memoryCache()->remove(resource.get());
475 return 0;
476 }
477 }
478
479 if (!request.resourceRequest().url().protocolIsData())
480 m_validatedURLs.add(request.resourceRequest().url());
481
482 ASSERT(resource->url() == url.string());
483 m_documentResources.set(resource->url(), resource);
484 return resource;
485 }
486
487 CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(const CachedResourceRequest& request, CachedResource* resource)
488 {
489 ASSERT(resource);
490 ASSERT(resource->inCache());
491 ASSERT(!memoryCache()->disabled());
492 ASSERT(resource->canUseCacheValidator());
493 ASSERT(!resource->resourceToRevalidate());
494
495 // Copy the URL out of the resource to be revalidated in case it gets deleted by the remove() call below.
496 String url = resource->url();
497 CachedResourceHandle<CachedResource> newResource = createResource(resource->type(), resource->resourceRequest(), resource->encoding());
498
499 LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
500 newResource->setResourceToRevalidate(resource);
501
502 memoryCache()->remove(resource);
503 memoryCache()->add(newResource.get());
504 #if ENABLE(RESOURCE_TIMING)
505 storeResourceTimingInitiatorInformation(resource, request);
506 #else
507 UNUSED_PARAM(request);
508 #endif
509 return newResource;
510 }
511
512 CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, CachedResourceRequest& request, const String& charset)
513 {
514 ASSERT(!memoryCache()->resourceForRequest(request.resourceRequest()));
515
516 LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
517
518 CachedResourceHandle<CachedResource> resource = createResource(type, request.mutableResourceRequest(), charset);
519
520 if (!memoryCache()->add(resource.get()))
521 resource->setOwningCachedResourceLoader(this);
522 #if ENABLE(RESOURCE_TIMING)
523 storeResourceTimingInitiatorInformation(resource, request);
524 #endif
525 return resource;
526 }
527
528 #if ENABLE(RESOURCE_TIMING)
529 void CachedResourceLoader::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const CachedResourceRequest& request)
530 {
531 if (resource->type() == CachedResource::MainResource) {
532 // <iframe>s should report the initial navigation requested by the parent document, but not subsequent navigations.
533 if (frame()->ownerElement() && m_documentLoader->frameLoader()->stateMachine().committingFirstRealLoad()) {
534 InitiatorInfo info = { frame()->ownerElement()->localName(), monotonicallyIncreasingTime() };
535 m_initiatorMap.add(resource.get(), info);
536 }
537 } else {
538 InitiatorInfo info = { request.initiatorName(), monotonicallyIncreasingTime() };
539 m_initiatorMap.add(resource.get(), info);
540 }
541 }
542 #endif // ENABLE(RESOURCE_TIMING)
543
544 CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalidationPolicy(CachedResource::Type type, ResourceRequest& request, bool forPreload, CachedResource* existingResource, CachedResourceRequest::DeferOption defer) const
545 {
546 if (!existingResource)
547 return Load;
548
549 // We already have a preload going for this URL.
550 if (forPreload && existingResource->isPreloaded())
551 return Use;
552
553 // If the same URL has been loaded as a different type, we need to reload.
554 if (existingResource->type() != type) {
555 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to type mismatch.");
556 return Reload;
557 }
558
559 if (!existingResource->canReuse(request))
560 return Reload;
561
562 // Conditional requests should have failed canReuse check.
563 ASSERT(!request.isConditional());
564
565 // Do not load from cache if images are not enabled. The load for this image will be blocked
566 // in CachedImage::load.
567 if (CachedResourceRequest::DeferredByClient == defer)
568 return Reload;
569
570 // Don't reload resources while pasting.
571 if (m_allowStaleResources)
572 return Use;
573
574 // Alwaus use preloads.
575 if (existingResource->isPreloaded())
576 return Use;
577
578 // CachePolicyHistoryBuffer uses the cache no matter what.
579 if (cachePolicy(type) == CachePolicyHistoryBuffer)
580 return Use;
581
582 // Don't reuse resources with Cache-control: no-store.
583 if (existingResource->response().cacheControlContainsNoStore()) {
584 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to Cache-control: no-store.");
585 return Reload;
586 }
587
588 // If credentials were sent with the previous request and won't be
589 // with this one, or vice versa, re-fetch the resource.
590 //
591 // This helps with the case where the server sends back
592 // "Access-Control-Allow-Origin: *" all the time, but some of the
593 // client's requests are made without CORS and some with.
594 if (existingResource->resourceRequest().allowCookies() != request.allowCookies()) {
595 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to difference in credentials settings.");
596 return Reload;
597 }
598
599 // During the initial load, avoid loading the same resource multiple times for a single document, even if the cache policies would tell us to.
600 if (document() && !document()->loadEventFinished() && m_validatedURLs.contains(existingResource->url()))
601 return Use;
602
603 // CachePolicyReload always reloads
604 if (cachePolicy(type) == CachePolicyReload) {
605 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to CachePolicyReload.");
606 return Reload;
607 }
608
609 // We'll try to reload the resource if it failed last time.
610 if (existingResource->errorOccurred()) {
611 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicye reloading due to resource being in the error state");
612 return Reload;
613 }
614
615 // For resources that are not yet loaded we ignore the cache policy.
616 if (existingResource->isLoading())
617 return Use;
618
619 // Check if the cache headers requires us to revalidate (cache expiration for example).
620 if (existingResource->mustRevalidateDueToCacheHeaders(cachePolicy(type))) {
621 // See if the resource has usable ETag or Last-modified headers.
622 if (existingResource->canUseCacheValidator())
623 return Revalidate;
624
625 // No, must reload.
626 LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to missing cache validators.");
627 return Reload;
628 }
629
630 return Use;
631 }
632
633 void CachedResourceLoader::printAccessDeniedMessage(const URL& url) const
634 {
635 if (url.isNull())
636 return;
637
638 if (!frame())
639 return;
640
641 String message;
642 if (!m_document || m_document->url().isNull())
643 message = "Unsafe attempt to load URL " + url.stringCenterEllipsizedToLength() + '.';
644 else
645 message = "Unsafe attempt to load URL " + url.stringCenterEllipsizedToLength() + " from frame with URL " + m_document->url().stringCenterEllipsizedToLength() + ". Domains, protocols and ports must match.\n";
646
647 frame()->document()->addConsoleMessage(MessageSource::Security, MessageLevel::Error, message);
648 }
649
650 void CachedResourceLoader::setAutoLoadImages(bool enable)
651 {
652 if (enable == m_autoLoadImages)
653 return;
654
655 m_autoLoadImages = enable;
656
657 if (!m_autoLoadImages)
658 return;
659
660 reloadImagesIfNotDeferred();
661 }
662
663 void CachedResourceLoader::setImagesEnabled(bool enable)
664 {
665 if (enable == m_imagesEnabled)
666 return;
667
668 m_imagesEnabled = enable;
669
670 if (!m_imagesEnabled)
671 return;
672
673 reloadImagesIfNotDeferred();
674 }
675
676 bool CachedResourceLoader::clientDefersImage(const URL& url) const
677 {
678 return frame() && !frame()->loader().client().allowImage(m_imagesEnabled, url);
679 }
680
681 bool CachedResourceLoader::shouldDeferImageLoad(const URL& url) const
682 {
683 return clientDefersImage(url) || !m_autoLoadImages;
684 }
685
686 void CachedResourceLoader::reloadImagesIfNotDeferred()
687 {
688 DocumentResourceMap::iterator end = m_documentResources.end();
689 for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it) {
690 CachedResource* resource = it->value.get();
691 if (resource->isImage() && resource->stillNeedsLoad() && !clientDefersImage(resource->url()))
692 const_cast<CachedResource*>(resource)->load(this, defaultCachedResourceOptions());
693 }
694 }
695
696 CachePolicy CachedResourceLoader::cachePolicy(CachedResource::Type type) const
697 {
698 if (!frame())
699 return CachePolicyVerify;
700
701 if (type != CachedResource::MainResource)
702 return frame()->loader().subresourceCachePolicy();
703
704 if (frame()->loader().loadType() == FrameLoadTypeReloadFromOrigin || frame()->loader().loadType() == FrameLoadTypeReload)
705 return CachePolicyReload;
706 return CachePolicyVerify;
707 }
708
709 void CachedResourceLoader::removeCachedResource(CachedResource* resource) const
710 {
711 #ifndef NDEBUG
712 DocumentResourceMap::iterator it = m_documentResources.find(resource->url());
713 if (it != m_documentResources.end())
714 ASSERT(it->value.get() == resource);
715 #endif
716 m_documentResources.remove(resource->url());
717 }
718
719 void CachedResourceLoader::loadDone(CachedResource* resource, bool shouldPerformPostLoadActions)
720 {
721 RefPtr<DocumentLoader> protectDocumentLoader(m_documentLoader);
722 RefPtr<Document> protectDocument(m_document);
723
724 #if ENABLE(RESOURCE_TIMING)
725 if (resource && resource->response().isHTTP() && ((!resource->errorOccurred() && !resource->wasCanceled()) || resource->response().httpStatusCode() == 304)) {
726 HashMap<CachedResource*, InitiatorInfo>::iterator initiatorIt = m_initiatorMap.find(resource);
727 if (initiatorIt != m_initiatorMap.end()) {
728 ASSERT(document());
729 Document* initiatorDocument = document();
730 if (resource->type() == CachedResource::MainResource)
731 initiatorDocument = document()->parentDocument();
732 ASSERT(initiatorDocument);
733 const InitiatorInfo& info = initiatorIt->value;
734 initiatorDocument->domWindow()->performance()->addResourceTiming(info.name, initiatorDocument, resource->resourceRequest(), resource->response(), info.startTime, resource->loadFinishTime());
735 m_initiatorMap.remove(initiatorIt);
736 }
737 }
738 #else
739 UNUSED_PARAM(resource);
740 #endif // ENABLE(RESOURCE_TIMING)
741
742 if (frame())
743 frame()->loader().loadDone();
744
745 if (shouldPerformPostLoadActions)
746 performPostLoadActions();
747
748 if (!m_garbageCollectDocumentResourcesTimer.isActive())
749 m_garbageCollectDocumentResourcesTimer.startOneShot(0);
750 }
751
752 // Garbage collecting m_documentResources is a workaround for the
753 // CachedResourceHandles on the RHS being strong references. Ideally this
754 // would be a weak map, however CachedResourceHandles perform additional
755 // bookkeeping on CachedResources, so instead pseudo-GC them -- when the
756 // reference count reaches 1, m_documentResources is the only reference, so
757 // remove it from the map.
758 void CachedResourceLoader::garbageCollectDocumentResourcesTimerFired(Timer<CachedResourceLoader>& timer)
759 {
760 ASSERT_UNUSED(timer, &timer == &m_garbageCollectDocumentResourcesTimer);
761 garbageCollectDocumentResources();
762 }
763
764 void CachedResourceLoader::garbageCollectDocumentResources()
765 {
766 typedef Vector<String, 10> StringVector;
767 StringVector resourcesToDelete;
768
769 for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != m_documentResources.end(); ++it) {
770 if (it->value->hasOneHandle()) {
771 resourcesToDelete.append(it->key);
772 it->value->setOwningCachedResourceLoader(0);
773 }
774 }
775
776 for (StringVector::const_iterator it = resourcesToDelete.begin(); it != resourcesToDelete.end(); ++it)
777 m_documentResources.remove(*it);
778 }
779
780 void CachedResourceLoader::performPostLoadActions()
781 {
782 checkForPendingPreloads();
783
784 platformStrategies()->loaderStrategy()->resourceLoadScheduler()->servePendingRequests();
785 }
786
787 void CachedResourceLoader::incrementRequestCount(const CachedResource* res)
788 {
789 if (res->ignoreForRequestCount())
790 return;
791
792 ++m_requestCount;
793 }
794
795 void CachedResourceLoader::decrementRequestCount(const CachedResource* res)
796 {
797 if (res->ignoreForRequestCount())
798 return;
799
800 --m_requestCount;
801 ASSERT(m_requestCount > -1);
802 }
803
804 void CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest& request, const String& charset)
805 {
806 // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
807 // FIXME: We should consider adding a setting to toggle aggressive preloading behavior as opposed
808 // to making this behavior specific to iOS.
809 #if !PLATFORM(IOS)
810 bool hasRendering = m_document->body() && m_document->renderView();
811 bool canBlockParser = type == CachedResource::Script || type == CachedResource::CSSStyleSheet;
812 if (!hasRendering && !canBlockParser) {
813 // Don't preload subresources that can't block the parser before we have something to draw.
814 // This helps prevent preloads from delaying first display when bandwidth is limited.
815 PendingPreload pendingPreload = { type, request, charset };
816 m_pendingPreloads.append(pendingPreload);
817 return;
818 }
819 #endif
820 requestPreload(type, request, charset);
821 }
822
823 void CachedResourceLoader::checkForPendingPreloads()
824 {
825 if (m_pendingPreloads.isEmpty() || !m_document || !m_document->body() || !m_document->body()->renderer())
826 return;
827 #if PLATFORM(IOS)
828 // We always preload resources on iOS. See <https://bugs.webkit.org/show_bug.cgi?id=91276>.
829 // So, we should never have any pending preloads.
830 // FIXME: We should look to avoid compiling this code entirely when building for iOS.
831 ASSERT_NOT_REACHED();
832 #endif
833 while (!m_pendingPreloads.isEmpty()) {
834 PendingPreload preload = m_pendingPreloads.takeFirst();
835 // Don't request preload if the resource already loaded normally (this will result in double load if the page is being reloaded with cached results ignored).
836 if (!cachedResource(preload.m_request.resourceRequest().url()))
837 requestPreload(preload.m_type, preload.m_request, preload.m_charset);
838 }
839 m_pendingPreloads.clear();
840 }
841
842 void CachedResourceLoader::requestPreload(CachedResource::Type type, CachedResourceRequest& request, const String& charset)
843 {
844 String encoding;
845 if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
846 encoding = charset.isEmpty() ? m_document->charset() : charset;
847
848 request.setCharset(encoding);
849 request.setForPreload(true);
850
851 CachedResourceHandle<CachedResource> resource = requestResource(type, request);
852 if (!resource || (m_preloads && m_preloads->contains(resource.get())))
853 return;
854 resource->increasePreloadCount();
855
856 if (!m_preloads)
857 m_preloads = adoptPtr(new ListHashSet<CachedResource*>);
858 m_preloads->add(resource.get());
859
860 #if PRELOAD_DEBUG
861 printf("PRELOADING %s\n", resource->url().latin1().data());
862 #endif
863 }
864
865 bool CachedResourceLoader::isPreloaded(const String& urlString) const
866 {
867 const URL& url = m_document->completeURL(urlString);
868
869 if (m_preloads) {
870 ListHashSet<CachedResource*>::iterator end = m_preloads->end();
871 for (ListHashSet<CachedResource*>::iterator it = m_preloads->begin(); it != end; ++it) {
872 CachedResource* resource = *it;
873 if (resource->url() == url)
874 return true;
875 }
876 }
877
878 Deque<PendingPreload>::const_iterator dequeEnd = m_pendingPreloads.end();
879 for (Deque<PendingPreload>::const_iterator it = m_pendingPreloads.begin(); it != dequeEnd; ++it) {
880 PendingPreload pendingPreload = *it;
881 if (pendingPreload.m_request.resourceRequest().url() == url)
882 return true;
883 }
884 return false;
885 }
886
887 void CachedResourceLoader::clearPreloads()
888 {
889 #if PRELOAD_DEBUG
890 printPreloadStats();
891 #endif
892 if (!m_preloads)
893 return;
894
895 ListHashSet<CachedResource*>::iterator end = m_preloads->end();
896 for (ListHashSet<CachedResource*>::iterator it = m_preloads->begin(); it != end; ++it) {
897 CachedResource* res = *it;
898 res->decreasePreloadCount();
899 bool deleted = res->deleteIfPossible();
900 if (!deleted && res->preloadResult() == CachedResource::PreloadNotReferenced)
901 memoryCache()->remove(res);
902 }
903 m_preloads.clear();
904 }
905
906 void CachedResourceLoader::clearPendingPreloads()
907 {
908 m_pendingPreloads.clear();
909 }
910
911 #if PRELOAD_DEBUG
912 void CachedResourceLoader::printPreloadStats()
913 {
914 unsigned scripts = 0;
915 unsigned scriptMisses = 0;
916 unsigned stylesheets = 0;
917 unsigned stylesheetMisses = 0;
918 unsigned images = 0;
919 unsigned imageMisses = 0;
920 ListHashSet<CachedResource*>::iterator end = m_preloads.end();
921 for (ListHashSet<CachedResource*>::iterator it = m_preloads.begin(); it != end; ++it) {
922 CachedResource* res = *it;
923 if (res->preloadResult() == CachedResource::PreloadNotReferenced)
924 printf("!! UNREFERENCED PRELOAD %s\n", res->url().latin1().data());
925 else if (res->preloadResult() == CachedResource::PreloadReferencedWhileComplete)
926 printf("HIT COMPLETE PRELOAD %s\n", res->url().latin1().data());
927 else if (res->preloadResult() == CachedResource::PreloadReferencedWhileLoading)
928 printf("HIT LOADING PRELOAD %s\n", res->url().latin1().data());
929
930 if (res->type() == CachedResource::Script) {
931 scripts++;
932 if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
933 scriptMisses++;
934 } else if (res->type() == CachedResource::CSSStyleSheet) {
935 stylesheets++;
936 if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
937 stylesheetMisses++;
938 } else {
939 images++;
940 if (res->preloadResult() < CachedResource::PreloadReferencedWhileLoading)
941 imageMisses++;
942 }
943
944 if (res->errorOccurred())
945 memoryCache()->remove(res);
946
947 res->decreasePreloadCount();
948 }
949 m_preloads.clear();
950
951 if (scripts)
952 printf("SCRIPTS: %d (%d hits, hit rate %d%%)\n", scripts, scripts - scriptMisses, (scripts - scriptMisses) * 100 / scripts);
953 if (stylesheets)
954 printf("STYLESHEETS: %d (%d hits, hit rate %d%%)\n", stylesheets, stylesheets - stylesheetMisses, (stylesheets - stylesheetMisses) * 100 / stylesheets);
955 if (images)
956 printf("IMAGES: %d (%d hits, hit rate %d%%)\n", images, images - imageMisses, (images - imageMisses) * 100 / images);
957 }
958 #endif
959
960 const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
961 {
962 static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForAllCredentials, DoSecurityCheck, UseDefaultOriginRestrictionsForType);
963 return options;
964 }
965
966 }