void ImageDocumentParser::finish() { if (!isStopped() && document()->imageElement() && document()->cachedImage()) { ImageResource* cachedImage = document()->cachedImage(); DocumentLoader* loader = document()->loader(); cachedImage->setResponse(loader->response()); cachedImage->setLoadFinishTime(loader->timing().responseEnd()); cachedImage->finish(); // Report the natural image size in the page title, regardless of zoom level. // At a zoom level of 1 the image is guaranteed to have an integer size. IntSize size = flooredIntSize(cachedImage->imageSize(LayoutObject::shouldRespectImageOrientation(document()->imageElement()->layoutObject()), 1.0f)); if (size.width()) { // Compute the title, we use the decoded filename of the resource, falling // back on the (decoded) hostname if there is no path. String fileName = decodeURLEscapeSequences(document()->url().lastPathComponent()); if (fileName.isEmpty()) fileName = document()->url().host(); document()->setTitle(imageTitle(fileName, size)); } document()->imageUpdated(); } // TODO(esprehn): These null checks on Document don't make sense, document() // will ASSERT if it was null. Do these want to check isDetached() ? if (document()) document()->finishedParsing(); }
DocumentLoadTiming* PerformanceTiming::documentLoadTiming() const { DocumentLoader* loader = documentLoader(); if (!loader) return nullptr; return &loader->timing(); }
ResourceLoadTiming* PerformanceTiming::resourceLoadTiming() const { DocumentLoader* loader = documentLoader(); if (!loader) return nullptr; return loader->response().resourceLoadTiming(); }
void PluginDocumentParser::createDocumentStructure() { RefPtr<Element> rootElement = document()->createElement(htmlTag, false); document()->appendChild(rootElement, IGNORE_EXCEPTION); static_cast<HTMLHtmlElement*>(rootElement.get())->insertedByParser(); if (document()->frame() && document()->frame()->loader()) document()->frame()->loader()->dispatchDocumentElementAvailable(); RefPtr<Element> body = document()->createElement(bodyTag, false); body->setAttribute(marginwidthAttr, "0"); body->setAttribute(marginheightAttr, "0"); body->setAttribute(styleAttr, "background-color: rgb(38,38,38)"); rootElement->appendChild(body, IGNORE_EXCEPTION); RefPtr<Element> embedElement = document()->createElement(embedTag, false); m_embedElement = static_cast<HTMLEmbedElement*>(embedElement.get()); m_embedElement->setAttribute(widthAttr, "100%"); m_embedElement->setAttribute(heightAttr, "100%"); m_embedElement->setAttribute(nameAttr, "plugin"); m_embedElement->setAttribute(srcAttr, document()->url().string()); DocumentLoader* loader = document()->loader(); ASSERT(loader); if (loader) m_embedElement->setAttribute(typeAttr, loader->writer()->mimeType()); static_cast<PluginDocument*>(document())->setPluginNode(m_embedElement); body->appendChild(embedElement, IGNORE_EXCEPTION); }
void MediaDocument::replaceMediaElementTimerFired(Timer<MediaDocument>&) { HTMLElement* htmlBody = body(); if (!htmlBody) return; // Set body margin width and height to 0 as that is what a PluginDocument uses. htmlBody->setAttribute(marginwidthAttr, "0"); htmlBody->setAttribute(marginheightAttr, "0"); if (HTMLVideoElement* videoElement = descendentVideoElement(*htmlBody)) { RefPtr<Element> element = Document::createElement(embedTag, false); HTMLEmbedElement* embedElement = toHTMLEmbedElement(element.get()); embedElement->setAttribute(widthAttr, "100%"); embedElement->setAttribute(heightAttr, "100%"); embedElement->setAttribute(nameAttr, "plugin"); embedElement->setAttribute(srcAttr, url().string()); DocumentLoader* documentLoader = loader(); ASSERT(documentLoader); if (documentLoader) embedElement->setAttribute(typeAttr, documentLoader->writer().mimeType()); videoElement->parentNode()->replaceChild(embedElement, videoElement, IGNORE_EXCEPTION); } }
CachePolicy FrameFetchContext::cachePolicy(Document* document) const { if (document && document->loadEventFinished()) return CachePolicyVerify; FrameLoadType loadType = m_frame->loader().loadType(); if (loadType == FrameLoadTypeReloadFromOrigin) return CachePolicyReload; Frame* parentFrame = m_frame->tree().parent(); if (parentFrame && parentFrame->isLocalFrame()) { CachePolicy parentCachePolicy = toLocalFrame(parentFrame)->loader().fetchContext().cachePolicy(toLocalFrame(parentFrame)->document()); if (parentCachePolicy != CachePolicyVerify) return parentCachePolicy; } if (loadType == FrameLoadTypeReload) return CachePolicyRevalidate; DocumentLoader* loader = document ? document->loader() : 0; if (loader && loader->request().cachePolicy() == ReturnCacheDataElseLoad) return CachePolicyHistoryBuffer; return CachePolicyVerify; }
PassRefPtr<SharedBuffer> InspectorResourceAgent::resourceData(Frame* frame, const KURL& url, String* textEncodingName) { FrameLoader* frameLoader = frame->loader(); DocumentLoader* loader = frameLoader->documentLoader(); if (equalIgnoringFragmentIdentifier(url, loader->url())) { *textEncodingName = frame->document()->inputEncoding(); return frameLoader->documentLoader()->mainResourceData(); } CachedResource* cachedResource = InspectorResourceAgent::cachedResource(frame, url); if (!cachedResource) return 0; // Zero-sized resources don't have data at all -- so fake the empty buffer, insted of indicating error by returning 0. if (!cachedResource->encodedSize()) return SharedBuffer::create(); if (cachedResource->isPurgeable()) { // If the resource is purgeable then make it unpurgeable to get // get its data. This might fail, in which case we return an // empty String. // FIXME: should we do something else in the case of a purged // resource that informs the user why there is no data in the // inspector? if (!cachedResource->makePurgeable(false)) return 0; } *textEncodingName = cachedResource->encoding(); return cachedResource->data(); }
void WebFrameLoaderClient::updateGlobalHistory() { WebHistory* history = WebHistory::sharedHistory(); if (!history) return; DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader(); history->addItem(loader->urlForHistory(), loader->title(), loader->urlForHistoryReflectsFailure()); }
void WebFrameLoaderClient::updateGlobalHistory() { WebHistory* history = WebHistory::sharedHistory(); if (!history) return; DocumentLoader* loader = core(m_webFrame)->loader()->documentLoader(); history->visitedURL(loader->urlForHistory(), loader->title(), loader->originalRequestCopy().httpMethod(), loader->urlForHistoryReflectsFailure(), !loader->clientRedirectSourceForHistory()); }
void InspectorApplicationCacheAgent::getManifestForFrame(ErrorString* errorString, const String& frameId, String* manifestURL) { DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId); if (!documentLoader) return; ApplicationCacheHost::CacheInfo info = documentLoader->applicationCacheHost()->applicationCacheInfo(); *manifestURL = info.m_manifest.string(); }
PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const String& markupString, Frame* frame, Vector<Node*>& nodes) { ASSERT(frame); const ResourceResponse& response = frame->loader()->documentLoader()->response(); KURL responseURL = response.url(); // it's possible to have a response without a URL here // <rdar://problem/5454935> if (responseURL.isNull()) responseURL = KURL(""); PassRefPtr<ArchiveResource> mainResource = ArchiveResource::create(utf8Buffer(markupString), responseURL, response.mimeType(), "UTF-8", frame->tree()->name()); Vector<PassRefPtr<LegacyWebArchive> > subframeArchives; Vector<PassRefPtr<ArchiveResource> > subresources; HashSet<String> uniqueSubresources; Vector<Node*>::iterator it = nodes.begin(); Vector<Node*>::iterator end = nodes.end(); for (; it != end; ++it) { Frame* childFrame; if (((*it)->hasTagName(HTMLNames::frameTag) || (*it)->hasTagName(HTMLNames::iframeTag) || (*it)->hasTagName(HTMLNames::objectTag)) && (childFrame = static_cast<HTMLFrameOwnerElement*>(*it)->contentFrame())) { RefPtr<LegacyWebArchive> subframeArchive; if (Document* document = childFrame->document()) subframeArchive = LegacyWebArchive::create(document); else subframeArchive = create(childFrame); if (subframeArchive) subframeArchives.append(subframeArchive); else LOG_ERROR("Unabled to archive subframe %s", childFrame->tree()->name().string().utf8().data()); } else { Vector<KURL> subresourceURLs; (*it)->getSubresourceURLs(subresourceURLs); DocumentLoader* documentLoader = frame->loader()->documentLoader(); for (unsigned i = 0; i < subresourceURLs.size(); ++i) { if (uniqueSubresources.contains(subresourceURLs[i].string())) continue; uniqueSubresources.add(subresourceURLs[i].string()); RefPtr<ArchiveResource> resource = documentLoader->subresource(subresourceURLs[i]); if (resource) subresources.append(resource.release()); else // FIXME: should do something better than spew to console here LOG_ERROR("Failed to archive subresource for %s", subresourceURLs[i].string().utf8().data()); } } } return create(mainResource, subresources, subframeArchives); }
bool PageCache::canCachePageContainingThisFrame(Frame& frame) { for (Frame* child = frame.tree().firstChild(); child; child = child->tree().nextSibling()) { if (!canCachePageContainingThisFrame(*child)) return false; } FrameLoader& frameLoader = frame.loader(); DocumentLoader* documentLoader = frameLoader.documentLoader(); Document* document = frame.document(); return documentLoader && (documentLoader->mainDocumentError().isNull() || (documentLoader->mainDocumentError().isCancellation() && documentLoader->subresourceLoadersArePageCacheAcceptable())) // Do not cache error pages (these can be recognized as pages with substitute data or unreachable URLs). && !(documentLoader->substituteData().isValid() && !documentLoader->substituteData().failingURL().isEmpty()) && (!frameLoader.subframeLoader().containsPlugins() || frame.page()->settings().pageCacheSupportsPlugins()) && !(frame.isMainFrame() && document->url().protocolIs("https") && documentLoader->response().cacheControlContainsNoStore()) && frameLoader.history().currentItem() && !frameLoader.quickRedirectComing() && !documentLoader->isLoading() && !documentLoader->isStopping() && document->canSuspendActiveDOMObjectsForPageCache() // FIXME: We should investigating caching frames that have an associated // application cache. <rdar://problem/5917899> tracks that work. && documentLoader->applicationCacheHost()->canCacheInPageCache() && frameLoader.client().canCachePage(); }
CertificateInfo WebFrame::certificateInfo() const { if (!m_coreFrame) return { }; DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader(); if (!documentLoader) return { }; return documentLoader->response().certificateInfo().valueOrCompute([] { return CertificateInfo(); }); }
void PluginView::cancelManualStreamLoad() { if (!frame()) return; DocumentLoader* documentLoader = frame()->loader()->activeDocumentLoader(); ASSERT(documentLoader); if (documentLoader->isLoadingMainResource()) documentLoader->cancelMainResourceLoad(frame()->loader()->cancelledError(m_parameters.url)); }
unsigned long long PerformanceTiming::responseStart() const { DocumentLoader* loader = documentLoader(); if (!loader) return requestStart(); const ResourceLoadTiming& timing = loader->response().resourceLoadTiming(); ASSERT(timing.responseStart >= 0); return resourceLoadTimeRelativeToAbsolute(timing.responseStart); }
static bool contentExtensionsEnabled(const DocumentLoader& documentLoader) { if (auto frame = documentLoader.frame()) { if (frame->isMainFrame()) return documentLoader.userContentExtensionsEnabled(); if (auto mainDocumentLoader = frame->mainFrame().loader().documentLoader()) return mainDocumentLoader->userContentExtensionsEnabled(); } return true; }
WebCore::CertificateInfo WebFrame::certificateInfo() const { if (!m_coreFrame) return CertificateInfo(); DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader(); if (!documentLoader) return CertificateInfo(); return documentLoader->response().certificateInfo(); }
void PluginDocument::cancelManualPluginLoad() { // PluginDocument::cancelManualPluginLoad should only be called once, but there are issues // with how many times we call beforeload on object elements. <rdar://problem/8441094>. if (!shouldLoadPluginManually()) return; DocumentLoader* documentLoader = frame()->loader().activeDocumentLoader(); documentLoader->cancelMainResourceLoad(frame()->loader().cancelledError(documentLoader->request())); setShouldLoadPluginManually(false); }
String WebFrame::url() const { if (!m_coreFrame) return String(); DocumentLoader* documentLoader = m_coreFrame->loader().documentLoader(); if (!documentLoader) return String(); return documentLoader->url().string(); }
String WebFrame::provisionalURL() const { if (!m_coreFrame) return String(); DocumentLoader* provisionalDocumentLoader = m_coreFrame->loader().provisionalDocumentLoader(); if (!provisionalDocumentLoader) return String(); return provisionalDocumentLoader->url().string(); }
void InspectorApplicationCacheAgent::getApplicationCaches(RefPtr<InspectorValue>* applicationCaches) { DocumentLoader* documentLoader = m_inspectorController->inspectedPage()->mainFrame()->loader()->documentLoader(); if (documentLoader) { ApplicationCacheHost* host = documentLoader->applicationCacheHost(); ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo(); ApplicationCacheHost::ResourceInfoList resources; host->fillResourceList(&resources); *applicationCaches = buildObjectForApplicationCache(resources, info); } }
void InspectorApplicationCacheAgent::getApplicationCaches(ErrorString*, RefPtr<InspectorObject>* applicationCaches) { DocumentLoader* documentLoader = m_inspectedPage->mainFrame()->loader()->documentLoader(); if (!documentLoader) return; ApplicationCacheHost* host = documentLoader->applicationCacheHost(); ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo(); ApplicationCacheHost::ResourceInfoList resources; host->fillResourceList(&resources); *applicationCaches = buildObjectForApplicationCache(resources, info); }
void ContentExtensionsBackend::processContentExtensionRulesForLoad(ResourceRequest& request, ResourceType resourceType, DocumentLoader& initiatingDocumentLoader) { Document* currentDocument = nullptr; URL mainDocumentURL; if (initiatingDocumentLoader.frame()) { currentDocument = initiatingDocumentLoader.frame()->document(); if (Document* mainDocument = initiatingDocumentLoader.frame()->mainFrame().document()) mainDocumentURL = mainDocument->url(); } ResourceLoadInfo resourceLoadInfo = { request.url(), mainDocumentURL, resourceType }; Vector<ContentExtensions::Action> actions = actionsForResourceLoad(resourceLoadInfo); StringBuilder css; bool willBlockLoad = false; for (const auto& action : actions) { switch (action.type()) { case ContentExtensions::ActionType::BlockLoad: willBlockLoad = true; break; case ContentExtensions::ActionType::BlockCookies: request.setAllowCookies(false); break; case ContentExtensions::ActionType::CSSDisplayNoneSelector: if (resourceType == ResourceType::Document) initiatingDocumentLoader.addPendingContentExtensionDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID()); else if (currentDocument) currentDocument->styleSheetCollection().addDisplayNoneSelector(action.extensionIdentifier(), action.stringArgument(), action.actionID()); break; case ContentExtensions::ActionType::CSSDisplayNoneStyleSheet: { StyleSheetContents* styleSheetContents = globalDisplayNoneStyleSheet(action.stringArgument()); if (styleSheetContents) { if (resourceType == ResourceType::Document) initiatingDocumentLoader.addPendingContentExtensionSheet(action.stringArgument(), *styleSheetContents); else if (currentDocument) currentDocument->styleSheetCollection().maybeAddContentExtensionSheet(action.stringArgument(), *styleSheetContents); } break; } case ContentExtensions::ActionType::IgnorePreviousRules: case ContentExtensions::ActionType::InvalidAction: RELEASE_ASSERT_NOT_REACHED(); } } if (willBlockLoad) { if (currentDocument) currentDocument->addConsoleMessage(MessageSource::ContentBlocker, MessageLevel::Info, makeString("Content blocker prevented frame displaying ", mainDocumentURL.string(), " from loading a resource from ", request.url().string())); request = ResourceRequest(); } }
static PassRefPtr<InspectorObject> buildObjectForFrameResource(Frame* frame) { FrameLoader* frameLoader = frame->loader(); DocumentLoader* loader = frameLoader->documentLoader(); RefPtr<InspectorObject> resourceObject = InspectorObject::create(); resourceObject->setString("url", loader->url().string()); resourceObject->setObject("loader", buildObjectForDocumentLoader(loader)); resourceObject->setObject("request", buildObjectForResourceRequest(loader->request())); resourceObject->setObject("response", buildObjectForResourceResponse(loader->response())); return resourceObject; }
void InspectorNetworkAgent::didLoadResourceFromMemoryCache(DocumentLoader& loader, CachedResource& resource) { String loaderId = m_pageAgent->loaderId(&loader); String frameId = m_pageAgent->frameId(loader.frame()); unsigned long identifier = loader.frame()->page()->progress().createUniqueIdentifier(); String requestId = IdentifiersFactory::requestId(identifier); m_resourcesData->resourceCreated(requestId, loaderId); m_resourcesData->addCachedResource(requestId, &resource); RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = buildInitiatorObject(loader.frame() ? loader.frame()->document() : nullptr); m_frontendDispatcher->requestServedFromMemoryCache(requestId, frameId, loaderId, loader.url().string(), timestamp(), initiatorObject, buildObjectForCachedResource(&resource, &loader)); }
Response InspectorApplicationCacheAgent::getManifestForFrame( const String& frameId, String* manifestURL) { DocumentLoader* documentLoader = nullptr; Response response = assertFrameWithDocumentLoader(frameId, documentLoader); if (!response.isSuccess()) return response; ApplicationCacheHost::CacheInfo info = documentLoader->applicationCacheHost()->applicationCacheInfo(); *manifestURL = info.m_manifest.getString(); return Response::OK(); }
void InspectorApplicationCacheAgent::updateApplicationCacheStatus(LocalFrame* frame) { DocumentLoader* documentLoader = frame->loader().documentLoader(); if (!documentLoader) return; ApplicationCacheHost* host = documentLoader->applicationCacheHost(); ApplicationCacheHost::Status status = host->status(); ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo(); String manifestURL = info.m_manifest.string(); m_frontend->applicationCacheStatusUpdated(m_pageAgent->frameId(frame), manifestURL, static_cast<int>(status)); }
unsigned long long PerformanceTiming::secureConnectionStart() const { DocumentLoader* loader = documentLoader(); if (!loader) return 0; const ResourceLoadTiming& timing = loader->response().resourceLoadTiming(); if (timing.secureConnectionStart < 0) return 0; return resourceLoadTimeRelativeToAbsolute(timing.secureConnectionStart); }
bool PageCache::canCachePageContainingThisFrame(Frame* frame) { for (Frame* child = frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) { if (!canCachePageContainingThisFrame(child)) return false; } FrameLoader* frameLoader = frame->loader(); DocumentLoader* documentLoader = frameLoader->documentLoader(); Document* document = frame->document(); return documentLoader && documentLoader->mainDocumentError().isNull() // Do not cache error pages (these can be recognized as pages with substitute data or unreachable URLs). && !(documentLoader->substituteData().isValid() && !documentLoader->substituteData().failingURL().isEmpty()) && (!frameLoader->subframeLoader()->containsPlugins() || frame->page()->settings()->pageCacheSupportsPlugins()) && (!document->url().protocolIs("https") || (!documentLoader->response().cacheControlContainsNoCache() && !documentLoader->response().cacheControlContainsNoStore())) && (!document->domWindow() || !document->domWindow()->hasEventListeners(eventNames().unloadEvent)) #if ENABLE(SQL_DATABASE) && !DatabaseManager::manager().hasOpenDatabases(document) #endif #if ENABLE(SHARED_WORKERS) && !SharedWorkerRepository::hasSharedWorkers(document) #endif && frameLoader->history()->currentItem() && !frameLoader->quickRedirectComing() && !documentLoader->isLoadingInAPISense() && !documentLoader->isStopping() && document->canSuspendActiveDOMObjects() // FIXME: We should investigating caching frames that have an associated // application cache. <rdar://problem/5917899> tracks that work. && documentLoader->applicationCacheHost()->canCacheInPageCache() && frameLoader->client()->canCachePage(); }
void InspectorApplicationCacheAgent::getApplicationCacheForFrame(ErrorString* errorString, const String& frameId, RefPtr<TypeBuilder::ApplicationCache::ApplicationCache>& applicationCache) { DocumentLoader* documentLoader = assertFrameWithDocumentLoader(errorString, frameId); if (!documentLoader) return; ApplicationCacheHost* host = documentLoader->applicationCacheHost(); ApplicationCacheHost::CacheInfo info = host->applicationCacheInfo(); ApplicationCacheHost::ResourceInfoList resources; host->fillResourceList(&resources); applicationCache = buildObjectForApplicationCache(resources, info); }