void InspectorPageAgent::searchInResource(ErrorString*, const String& frameId, const String& url, const String& query, const bool* const optionalCaseSensitive, const bool* const optionalIsRegex, RefPtr<TypeBuilder::Array<TypeBuilder::Page::SearchMatch> >& results) { results = TypeBuilder::Array<TypeBuilder::Page::SearchMatch>::create(); bool isRegex = optionalIsRegex ? *optionalIsRegex : false; bool caseSensitive = optionalCaseSensitive ? *optionalCaseSensitive : false; LocalFrame* frame = frameForId(frameId); KURL kurl(ParsedURLString, url); FrameLoader* frameLoader = frame ? &frame->loader() : 0; DocumentLoader* loader = frameLoader ? frameLoader->documentLoader() : 0; if (!loader) return; String content; bool success = false; Resource* resource = cachedResource(frame, kurl); if (resource) success = textContentForResource(resource, &content); if (!success) return; results = ContentSearchUtils::searchInTextByLines(content, query, caseSensitive, isRegex); }
// static void InspectorPageAgent::resourceContent(ErrorString* errorString, Frame* frame, const KURL& url, String* result, bool* base64Encoded) { if (!frame) { *errorString = "No frame to get resource content for"; return; } FrameLoader* frameLoader = frame->loader(); DocumentLoader* loader = frameLoader->documentLoader(); if (!loader) { *errorString = "No documentLoader for frame to get resource content for"; return; } RefPtr<SharedBuffer> buffer; bool success = false; if (equalIgnoringFragmentIdentifier(url, loader->url())) { *base64Encoded = false; success = mainResourceContent(frame, *base64Encoded, result); } if (!success) success = cachedResourceContent(cachedResource(frame, url), result, base64Encoded); if (!success) *errorString = "No resource with given URL found"; }
// static void InspectorPageAgent::resourceContent(ErrorString* errorString, LocalFrame* frame, const KURL& url, String* result, bool* base64Encoded) { DocumentLoader* loader = assertDocumentLoader(errorString, frame); if (!loader) return; if (!cachedResourceContent(cachedResource(frame, url), result, base64Encoded)) *errorString = "No resource with given URL found"; }
void CachedResourceLoader::checkForPendingPreloads() { if (m_pendingPreloads.isEmpty() || !m_document->body() || !m_document->body()->renderer()) return; while (!m_pendingPreloads.isEmpty()) { PendingPreload preload = m_pendingPreloads.takeFirst(); // 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). if (!cachedResource(preload.m_request.url())) requestPreload(preload.m_type, preload.m_request, preload.m_charset); } m_pendingPreloads.clear(); }
void DocLoader::checkForPendingPreloads() { unsigned count = m_pendingPreloads.size(); if (!count || !m_doc->body() || !m_doc->body()->renderer()) return; for (unsigned i = 0; i < count; ++i) { PendingPreload& preload = m_pendingPreloads[i]; // 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). if (!cachedResource(m_doc->completeURL(preload.m_url))) requestPreload(preload.m_type, preload.m_url, preload.m_charset); } m_pendingPreloads.clear(); }
const AtomicString& InspectorPageAgent::resourceSourceMapURL(const String& url) { DEFINE_STATIC_LOCAL(const AtomicString, sourceMapHttpHeader, ("SourceMap", AtomicString::ConstructFromLiteral)); DEFINE_STATIC_LOCAL(const AtomicString, deprecatedSourceMapHttpHeader, ("X-SourceMap", AtomicString::ConstructFromLiteral)); if (url.isEmpty()) return nullAtom; LocalFrame* frame = mainFrame(); if (!frame) return nullAtom; Resource* resource = cachedResource(frame, KURL(ParsedURLString, url)); if (!resource) return nullAtom; const AtomicString& deprecatedHeaderSourceMapURL = resource->response().httpHeaderField(deprecatedSourceMapHttpHeader); if (!deprecatedHeaderSourceMapURL.isEmpty()) { // FIXME: add deprecated console message here. return deprecatedHeaderSourceMapURL; } return resource->response().httpHeaderField(sourceMapHttpHeader); }
ResourceFetcher::RevalidationPolicy ResourceFetcher::determineRevalidationPolicy(Resource::Type type, const FetchRequest& fetchRequest, Resource* existingResource) const { const ResourceRequest& request = fetchRequest.resourceRequest(); if (!existingResource) return Load; // If the same URL has been loaded as a different type, we need to reload. if (existingResource->type() != type) { WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to type mismatch."); return Reload; } // Do not load from cache if images are not enabled. The load for this image will be blocked // in ImageResource::load. if (FetchRequest::DeferredByClient == fetchRequest.defer()) return Reload; // Always use data uris. // FIXME: Extend this to non-images. if (type == Resource::Image && request.url().protocolIsData()) return Use; if (!existingResource->canReuse(request)) return Reload; // Never use cache entries for downloadToFile requests. The caller expects the resource in a file. if (request.downloadToFile()) return Reload; // Certain requests (e.g., XHRs) might have manually set headers that require revalidation. // FIXME: In theory, this should be a Revalidate case. In practice, the MemoryCache revalidation path assumes a whole bunch // of things about how revalidation works that manual headers violate, so punt to Reload instead. if (request.isConditional()) return Reload; // Don't reload resources while pasting. if (m_allowStaleResources) return Use; if (!fetchRequest.options().canReuseRequest(existingResource->options())) return Reload; // CachePolicyHistoryBuffer uses the cache no matter what. CachePolicy cachePolicy = context().cachePolicy(document()); if (cachePolicy == CachePolicyHistoryBuffer) return Use; // Don't reuse resources with Cache-control: no-store. if (existingResource->hasCacheControlNoStoreHeader()) { WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to Cache-control: no-store."); return Reload; } // If credentials were sent with the previous request and won't be // with this one, or vice versa, re-fetch the resource. // // This helps with the case where the server sends back // "Access-Control-Allow-Origin: *" all the time, but some of the // client's requests are made without CORS and some with. if (existingResource->resourceRequest().allowStoredCredentials() != request.allowStoredCredentials()) { WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to difference in credentials settings."); return Reload; } // During the initial load, avoid loading the same resource multiple times for a single document, // even if the cache policies would tell us to. // We also group loads of the same resource together. // Raw resources are exempted, as XHRs fall into this category and may have user-set Cache-Control: // headers or other factors that require separate requests. if (type != Resource::Raw) { if (document() && !document()->loadEventFinished() && m_validatedURLs.contains(existingResource->url())) return Use; if (existingResource->isLoading()) return Use; } // CachePolicyReload always reloads if (cachePolicy == CachePolicyReload) { WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to CachePolicyReload."); return Reload; } // We'll try to reload the resource if it failed last time. if (existingResource->errorOccurred()) { WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicye reloading due to resource being in the error state"); return Reload; } // List of available images logic allows images to be re-used without cache validation. We restrict this only to images // from memory cache which are the same as the version in the current document. if (type == Resource::Image && existingResource == cachedResource(request.url())) return Use; // Check if the cache headers requires us to revalidate (cache expiration for example). if (cachePolicy == CachePolicyRevalidate || existingResource->mustRevalidateDueToCacheHeaders() || request.cacheControlContainsNoCache()) { // See if the resource has usable ETag or Last-modified headers. if (existingResource->canUseCacheValidator()) return Revalidate; // No, must reload. WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to missing cache validators."); return Reload; } return Use; }
CachedResource* CachedResourceLoader::cachedResource(const String& resourceURL) const { KURL url = m_document->completeURL(resourceURL); return cachedResource(url); }