static JSValueRef getResourceDocumentNode(JSContextRef ctx, JSObjectRef /*function*/, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* /*exception*/)
{
JSValueRef undefined = JSValueMakeUndefined(ctx);
InspectorController* controller = reinterpret_cast<InspectorController*>(JSObjectGetPrivate(thisObject));
if (!argumentCount || argumentCount > 1 || !controller)
return undefined;
JSValueRef identifierValue = arguments[0];
if (!JSValueIsNumber(ctx, identifierValue))
return undefined;
unsigned long identifier = static_cast<unsigned long>(JSValueToNumber(ctx, identifierValue, 0));
RefPtr<InspectorResource> resource = controller->resources().get(identifier);
ASSERT(resource);
if (!resource)
return undefined;
FrameLoader* frameLoader = resource->loader->frameLoader();
if (!frameLoader)
return undefined;
Document* document = frameLoader->frame()->document();
if (!document)
return undefined;
if (document->isPluginDocument() || document->isImageDocument())
return undefined;
KJS::JSLock lock;
JSValueRef documentValue = toRef(toJS(toJS(controller->scriptContext()), document));
return documentValue;
}
Type type() const
{
if (requestURL == loader->requestURL())
return Doc;
FrameLoader* frameLoader = loader->frameLoader();
if (!frameLoader)
return Other;
if (requestURL == frameLoader->iconURL())
return Image;
Document* doc = frameLoader->frame()->document();
if (!doc)
return Other;
CachedResource* cachedResource = doc->docLoader()->cachedResource(requestURL.url());
if (!cachedResource)
return Other;
switch (cachedResource->type()) {
case CachedResource::ImageResource:
return Image;
case CachedResource::CSSStyleSheet:
#if ENABLE(XSLT)
case CachedResource::XSLStyleSheet:
#endif
return Stylesheet;
case CachedResource::Script:
return Script;
default:
return Other;
}
}
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;
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();
}
bool SubframeLoader::loadPlugin(HTMLPlugInImageElement* pluginElement, const KURL& url, const String& mimeType,
const Vector<String>& paramNames, const Vector<String>& paramValues, bool useFallback)
{
RenderEmbeddedObject* renderer = pluginElement->renderEmbeddedObject();
// FIXME: This code should not depend on renderer!
if (!renderer || useFallback)
return false;
if (!document()->securityOrigin()->canDisplay(url)) {
FrameLoader::reportLocalLoadFailed(m_frame, url.string());
return false;
}
FrameLoader* frameLoader = m_frame->loader();
frameLoader->checkIfRunInsecureContent(document()->securityOrigin(), url);
IntSize contentSize(renderer->contentWidth(), renderer->contentHeight());
bool loadManually = document()->isPluginDocument() && !m_containsPlugins;
RefPtr<Widget> widget = frameLoader->client()->createPlugin(contentSize,
pluginElement, url, paramNames, paramValues, mimeType, loadManually);
if (!widget) {
renderer->setShowsMissingPluginIndicator();
return false;
}
renderer->setWidget(widget);
m_containsPlugins = true;
#if ENABLE(PLUGIN_PROXY_FOR_VIDEO)
pluginElement->setNeedsStyleRecalc(SyntheticStyleChange);
#endif
return true;
}
PassRefPtr<HistoryItem> HistoryController::createItemTree(Frame* targetFrame, bool clipAtTarget)
{
RefPtr<HistoryItem> bfItem = createItem();
saveScrollPositionAndViewStateToItem(m_previousItem.get());
if (!clipAtTarget || m_frame != targetFrame) {
// save frame state for items that aren't loading (khtml doesn't save those)
saveDocumentState();
// clipAtTarget is false for navigations within the same document, so
// we should copy the documentSequenceNumber over to the newly create
// item. Non-target items are just clones, and they should therefore
// preserve the same itemSequenceNumber.
if (m_previousItem) {
if (m_frame != targetFrame)
bfItem->setItemSequenceNumber(m_previousItem->itemSequenceNumber());
bfItem->setDocumentSequenceNumber(m_previousItem->documentSequenceNumber());
}
for (Frame* child = m_frame->tree()->firstChild(); child; child = child->tree()->nextSibling()) {
// If the child is a frame corresponding to an <object> element that never loaded,
// we don't want to create a history item, because that causes fallback content
// to be ignored on reload.
FrameLoader* childLoader = child->loader();
if (childLoader->stateMachine()->startedFirstRealLoad() || !child->ownerElement()->isObjectElement())
bfItem->addChildItem(childLoader->history()->createItemTree(targetFrame, clipAtTarget));
}
}
// FIXME: Eliminate the isTargetItem flag in favor of itemSequenceNumber.
if (m_frame == targetFrame)
bfItem->setIsTargetItem(true);
return bfItem;
}
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);
}
void FrameLoaderClient::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
{
if (!m_pluginView) {
ASSERT(loader->frame());
// Setting the encoding on the frame loader is our way to get work done that is normally done
// when the first bit of data is received, even for the case of a document with no data (like about:blank).
String encoding = loader->overrideEncoding();
bool userChosen = !encoding.isNull();
if (!userChosen)
encoding = loader->response().textEncodingName();
FrameLoader* frameLoader = loader->frameLoader();
frameLoader->setEncoding(encoding, userChosen);
if (data)
frameLoader->addData(data, length);
}
if (m_pluginView) {
if (!m_hasSentResponseToPlugin) {
m_pluginView->didReceiveResponse(loader->response());
m_hasSentResponseToPlugin = true;
}
// FIXME: We may want to investigate refactoring our plugin loading
// code to be similar to mac's.
// Also, see http://trac.webkit.org/changeset/24118.
if (!m_pluginView)
return;
m_pluginView->didReceiveData(data, length);
}
}
void HTMLVideoElement::setDisplayMode(DisplayMode mode)
{
DisplayMode oldMode = displayMode();
KURL poster = getNonEmptyURLAttribute(posterAttr);
if (!poster.isEmpty()) {
// We have a poster path, but only show it until the user triggers display by playing or seeking and the
// media engine has something to display.
if (mode == Video) {
if (oldMode != Video && player())
player()->prepareForRendering();
if (!hasAvailableVideoFrame())
mode = PosterWaitingForVideo;
}
} else if (oldMode != Video && player())
player()->prepareForRendering();
HTMLMediaElement::setDisplayMode(mode);
if (player() && player()->canLoadPoster()) {
bool canLoad = true;
if (!poster.isEmpty()) {
Frame* frame = document()->frame();
FrameLoader* loader = frame ? frame->loader() : 0;
canLoad = loader && loader->willLoadMediaElementURL(poster);
}
if (canLoad)
player()->setPoster(poster);
}
#if !ENABLE(PLUGIN_PROXY_FOR_VIDEO)
if (renderer() && displayMode() != oldMode)
renderer()->updateFromElement();
#endif
}
void RedirectScheduler::scheduleLocationChange(const String& url, const String& referrer, bool lockHistory, bool lockBackForwardList, bool wasUserGesture)
{
if (!m_frame->page())
return;
if (url.isEmpty())
return;
lockBackForwardList = lockBackForwardList || mustLockBackForwardList(m_frame);
FrameLoader* loader = m_frame->loader();
// If the URL we're going to navigate to is the same as the current one, except for the
// fragment part, we don't need to schedule the location change.
KURL parsedURL(ParsedURLString, url);
if (parsedURL.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(loader->url(), parsedURL)) {
loader->changeLocation(loader->completeURL(url), referrer, lockHistory, lockBackForwardList, wasUserGesture);
return;
}
// Handle a location change of a page with no document as a special case.
// This may happen when a frame changes the location of another frame.
bool duringLoad = !loader->committedFirstRealDocumentLoad();
schedule(new ScheduledLocationChange(url, referrer, lockHistory, lockBackForwardList, wasUserGesture, duringLoad));
}
void FrameLoaderClientQt::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
{
if (!m_pluginView) {
if (!m_frame)
return;
FrameLoader *fl = loader->frameLoader();
if (m_firstData) {
fl->setEncoding(m_response.textEncodingName(), false);
m_firstData = false;
}
fl->addData(data, length);
}
// We re-check here as the plugin can have been created
if (m_pluginView && m_pluginView->isPluginView()) {
if (!m_hasSentResponseToPlugin) {
m_pluginView->didReceiveResponse(loader->response());
// didReceiveResponse sets up a new stream to the plug-in. on a full-page plug-in, a failure in
// setting up this stream can cause the main document load to be cancelled, setting m_pluginView
// to null
if (!m_pluginView)
return;
m_hasSentResponseToPlugin = true;
}
m_pluginView->didReceiveData(data, length);
}
}
void HistoryController::updateForCommit()
{
FrameLoader* frameLoader = m_frame->loader();
#if !LOG_DISABLED
if (frameLoader->documentLoader())
LOG(History, "WebCoreHistory: Updating History for commit in frame %s", frameLoader->documentLoader()->title().string().utf8().data());
#endif
FrameLoadType type = frameLoader->loadType();
if (isBackForwardLoadType(type)
|| isReplaceLoadTypeWithProvisionalItem(type)
|| (isReloadTypeWithProvisionalItem(type) && !frameLoader->provisionalDocumentLoader()->unreachableURL().isEmpty())) {
// Once committed, we want to use current item for saving DocState, and
// the provisional item for restoring state.
// Note previousItem must be set before we close the URL, which will
// happen when the data source is made non-provisional below
m_frameLoadComplete = false;
m_previousItem = m_currentItem;
ASSERT(m_provisionalItem);
m_currentItem = m_provisionalItem;
m_provisionalItem = 0;
// Tell all other frames in the tree to commit their provisional items and
// restore their scroll position. We'll avoid this frame (which has already
// committed) and its children (which will be replaced).
Page* page = m_frame->page();
ASSERT(page);
page->mainFrame()->loader()->history()->recursiveUpdateForCommit();
}
}
bool InspectorBackend::addSourceToFrame(const String& mimeType, const String& source, Node* frameNode)
{
ASSERT_ARG(frameNode, frameNode);
if (!frameNode)
return false;
if (!frameNode->attached()) {
ASSERT_NOT_REACHED();
return false;
}
ASSERT(frameNode->isElementNode());
if (!frameNode->isElementNode())
return false;
Element* element = static_cast<Element*>(frameNode);
ASSERT(element->isFrameOwnerElement());
if (!element->isFrameOwnerElement())
return false;
HTMLFrameOwnerElement* frameOwner = static_cast<HTMLFrameOwnerElement*>(element);
ASSERT(frameOwner->contentFrame());
if (!frameOwner->contentFrame())
return false;
FrameLoader* loader = frameOwner->contentFrame()->loader();
loader->setResponseMIMEType(mimeType);
loader->begin();
loader->write(source);
loader->end();
return true;
}
// 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";
}
// This function should only be called when frameLoader() is non-null.
FrameLoader& ResourceLoader::dataProtocolFrameLoader() const
{
FrameLoader* loader = frameLoader();
ASSERT(loader);
FrameLoader* dataProtocolLoader = loader->client().dataProtocolLoader();
return *(dataProtocolLoader ? dataProtocolLoader : loader);
}
void CachedResource::addAdditionalRequestHeaders(CachedResourceLoader* cachedResourceLoader)
{
// Note: We skip the Content-Security-Policy check here because we check
// the Content-Security-Policy at the CachedResourceLoader layer so we can
// handle different resource types differently.
FrameLoader* frameLoader = cachedResourceLoader->frame()->loader();
String outgoingReferrer;
String outgoingOrigin;
if (m_resourceRequest.httpReferrer().isNull()) {
outgoingReferrer = frameLoader->outgoingReferrer();
outgoingOrigin = frameLoader->outgoingOrigin();
} else {
outgoingReferrer = m_resourceRequest.httpReferrer();
outgoingOrigin = SecurityOrigin::createFromString(outgoingReferrer)->toString();
}
outgoingReferrer = SecurityPolicy::generateReferrerHeader(cachedResourceLoader->document()->referrerPolicy(), m_resourceRequest.url(), outgoingReferrer);
if (outgoingReferrer.isEmpty())
m_resourceRequest.clearHTTPReferrer();
else if (!m_resourceRequest.httpReferrer())
m_resourceRequest.setHTTPReferrer(outgoingReferrer);
FrameLoader::addHTTPOriginIfNeeded(m_resourceRequest, outgoingOrigin);
frameLoader->addExtraFieldsToSubresourceRequest(m_resourceRequest);
}
// Cancels the data source's pending loads. Conceptually, a data source only loads
// one document at a time, but one document may have many related resources.
// stopLoading will stop all loads initiated by the data source,
// but not loads initiated by child frames' data sources -- that's the WebFrame's job.
void DocumentLoader::stopLoading()
{
// In some rare cases, calling FrameLoader::stopLoading could set m_loading to false.
// (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it
// to stop loading. Because of this, we need to save it so we don't return early.
bool loading = m_loading;
if (m_committed) {
// Attempt to stop the frame if the document loader is loading, or if it is done loading but
// still parsing. Failure to do so can cause a world leak.
Document* doc = m_frame->document();
if (loading || doc->parsing())
m_frame->loader()->stopLoading(UnloadEventPolicyNone);
}
// Always cancel multipart loaders
cancelAll(m_multipartSubresourceLoaders);
// Appcache uses ResourceHandle directly, DocumentLoader doesn't count these loads.
m_applicationCacheHost->stopLoadingInFrame(m_frame);
if (!loading) {
// If something above restarted loading we might run into mysterious crashes like
// https://bugs.webkit.org/show_bug.cgi?id=62764 and <rdar://problem/9328684>
ASSERT(!m_loading);
return;
}
// We might run in to infinite recursion if we're stopping loading as the result of
// detaching from the frame, so break out of that recursion here.
// See <rdar://problem/9673866> for more details.
if (m_isStopping)
return;
RefPtr<Frame> protectFrame(m_frame);
RefPtr<DocumentLoader> protectLoader(this);
m_isStopping = true;
FrameLoader* frameLoader = DocumentLoader::frameLoader();
if (m_mainResourceLoader)
// Stop the main resource loader and let it send the cancelled message.
m_mainResourceLoader->cancel();
else if (!m_subresourceLoaders.isEmpty())
// The main resource loader already finished loading. Set the cancelled error on the
// document and let the subresourceLoaders send individual cancelled messages below.
setMainDocumentError(frameLoader->cancelledError(m_request));
else
// If there are no resource loaders, we need to manufacture a cancelled message.
// (A back/forward navigation has no resource loaders because its resources are cached.)
mainReceivedError(frameLoader->cancelledError(m_request), true);
stopLoadingSubresources();
stopLoadingPlugIns();
m_isStopping = false;
}
void FrameLoaderClientWx::committedLoad(WebCore::DocumentLoader* loader, const char* data, int length)
{
if (!m_frame)
return;
FrameLoader* fl = loader->frameLoader();
fl->setEncoding(m_response.textEncodingName(), false);
fl->addData(data, length);
}
Page* InspectorOverlay::overlayPage()
{
if (m_overlayPage)
return m_overlayPage.get();
static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
Page::PageClients pageClients;
fillWithEmptyClients(pageClients);
ASSERT(!m_overlayChromeClient);
m_overlayChromeClient = adoptPtr(new InspectorOverlayChromeClient(m_page->chrome().client(), this));
pageClients.chromeClient = m_overlayChromeClient.get();
m_overlayPage = adoptPtr(new Page(pageClients));
m_overlayPage->setGroupType(Page::InspectorPageGroup);
Settings* settings = m_page->settings();
Settings* overlaySettings = m_overlayPage->settings();
overlaySettings->setStandardFontFamily(settings->standardFontFamily());
overlaySettings->setSerifFontFamily(settings->serifFontFamily());
overlaySettings->setSansSerifFontFamily(settings->sansSerifFontFamily());
overlaySettings->setCursiveFontFamily(settings->cursiveFontFamily());
overlaySettings->setFantasyFontFamily(settings->fantasyFontFamily());
overlaySettings->setPictographFontFamily(settings->pictographFontFamily());
overlaySettings->setMinimumFontSize(settings->minimumFontSize());
overlaySettings->setMinimumLogicalFontSize(settings->minimumLogicalFontSize());
overlaySettings->setMediaEnabled(false);
overlaySettings->setScriptEnabled(true);
overlaySettings->setPluginsEnabled(false);
overlaySettings->setLoadsImagesAutomatically(true);
RefPtr<Frame> frame = Frame::create(m_overlayPage.get(), 0, dummyFrameLoaderClient);
frame->setView(FrameView::create(frame.get()));
frame->init();
FrameLoader* loader = frame->loader();
frame->view()->setCanHaveScrollbars(false);
frame->view()->setTransparent(true);
ASSERT(loader->activeDocumentLoader());
DocumentWriter* writer = loader->activeDocumentLoader()->beginWriting("text/html", "UTF-8");
writer->addData(reinterpret_cast<const char*>(InspectorOverlayPage_html), sizeof(InspectorOverlayPage_html));
writer->end();
v8::HandleScope handleScope;
v8::Handle<v8::Context> frameContext = frame->script()->currentWorldContext();
v8::Context::Scope contextScope(frameContext);
v8::Handle<v8::Value> overlayHostObj = toV8(m_overlayHost.get(), v8::Handle<v8::Object>(), frameContext->GetIsolate());
v8::Handle<v8::Object> global = frameContext->Global();
global->Set(v8::String::New("InspectorOverlayHost"), overlayHostObj);
#if OS(WINDOWS)
evaluateInOverlay("setPlatform", "windows");
#elif OS(DARWIN)
evaluateInOverlay("setPlatform", "mac");
#elif OS(UNIX)
evaluateInOverlay("setPlatform", "linux");
#endif
return m_overlayPage.get();
}
void FrameLoaderClientEfl::dispatchDidFailLoading(DocumentLoader* loader, unsigned long identifier, const ResourceError&)
{
if (m_firstData) {
FrameLoader* fl = loader->frameLoader();
fl->writer()->setEncoding(m_response.textEncodingName(), false);
m_firstData = false;
}
}
static bool webKitWebSrcStart(WebKitWebSrc* src)
{
WebKitWebSrcPrivate* priv = src->priv;
if (!priv->uri) {
GST_ERROR_OBJECT(src, "No URI provided");
return false;
}
KURL url = KURL(KURL(), priv->uri);
ResourceRequest request(url);
request.setTargetType(ResourceRequestBase::TargetIsMedia);
request.setAllowCookies(true);
NetworkingContext* context = 0;
if (priv->frame) {
Document* document = priv->frame->document();
if (document)
request.setHTTPReferrer(document->documentURI());
FrameLoader* loader = priv->frame->loader();
if (loader) {
loader->addExtraFieldsToSubresourceRequest(request);
context = loader->networkingContext();
}
}
// Let Apple web servers know we want to access their nice movie trailers.
if (!g_ascii_strcasecmp("movies.apple.com", url.host().utf8().data())
|| !g_ascii_strcasecmp("trailers.apple.com", url.host().utf8().data()))
request.setHTTPUserAgent("Quicktime/7.6.6");
if (priv->requestedOffset) {
GOwnPtr<gchar> val;
val.set(g_strdup_printf("bytes=%" G_GUINT64_FORMAT "-", priv->requestedOffset));
request.setHTTPHeaderField("Range", val.get());
}
if (priv->iradioMode)
request.setHTTPHeaderField("icy-metadata", "1");
// Needed to use DLNA streaming servers
request.setHTTPHeaderField("transferMode.dlna", "Streaming");
priv->resourceHandle = ResourceHandle::create(context, request, priv->client, false, false);
if (!priv->resourceHandle) {
GST_ERROR_OBJECT(src, "Failed to create ResourceHandle");
return false;
}
GST_DEBUG_OBJECT(src, "Started request");
return true;
}
Frame* ResourceLoader::getFrame()
{
Frame* retVal = NULL;
FrameLoader* pFrameLoader = frameLoader();
if(pFrameLoader != NULL)
{
retVal = pFrameLoader->frame();
}
return retVal;
}
void FrameLoaderClientQt::dispatchDidFailLoading(WebCore::DocumentLoader* loader, unsigned long identifier, const WebCore::ResourceError& error)
{
if (dumpResourceLoadCallbacks)
printf("%s - didFailLoadingWithError: %s\n", qPrintable(dumpAssignedUrls[identifier]), qPrintable(drtDescriptionSuitableForTestResult(error)));
if (m_firstData) {
FrameLoader *fl = loader->frameLoader();
fl->setEncoding(m_response.textEncodingName(), false);
m_firstData = false;
}
}
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;
}
/**
* webkit_web_data_source_get_web_frame:
* @data_source: a #WebKitWebDataSource
*
* Returns the #WebKitWebFrame that represents this data source
*
* Return value: (transfer none): the #WebKitWebFrame that represents
* the @data_source. The #WebKitWebFrame is owned by WebKit and should
* not be freed or destroyed. This will return %NULL if the
* @data_source is not attached to a frame.
*
* Since: 1.1.14
*/
WebKitWebFrame* webkit_web_data_source_get_web_frame(WebKitWebDataSource* webDataSource)
{
g_return_val_if_fail(WEBKIT_IS_WEB_DATA_SOURCE(webDataSource), NULL);
WebKitWebDataSourcePrivate* priv = webDataSource->priv;
FrameLoader* frameLoader = priv->loader->frameLoader();
if (!frameLoader)
return NULL;
return static_cast<WebKit::FrameLoaderClient*>(frameLoader->client())->webFrame();
}
QList<QObject*> QWebFrameAdapter::childFrames() const
{
QList<QObject*> originatingObjects;
if (frame) {
FrameTree* tree = frame->tree();
for (Frame* child = tree->firstChild(); child; child = child->tree()->nextSibling()) {
FrameLoader* loader = child->loader();
originatingObjects.append(loader->networkingContext()->originatingObject());
}
}
return originatingObjects;
}
virtual void fire(Frame* frame)
{
FrameLoader* loader = frame->loader();
if (!m_historySteps) {
// Special case for go(0) from a frame -> reload only the frame
loader->urlSelected(loader->url(), "", 0, lockHistory(), lockBackForwardList(), false, SendReferrer);
return;
}
// go(i!=0) from a frame navigates into the history of the frame only,
// in both IE and NS (but not in Mozilla). We can't easily do that.
frame->page()->goBackOrForward(m_historySteps);
}
//------- WebKit/plugin resource load notifications ---------------
void WebDevToolsAgentImpl::identifierForInitialRequest(
unsigned long resourceId,
WebFrame* frame,
const WebURLRequest& request)
{
if (InspectorController* ic = inspectorController()) {
WebFrameImpl* webFrameImpl = static_cast<WebFrameImpl*>(frame);
FrameLoader* frameLoader = webFrameImpl->frame()->loader();
DocumentLoader* loader = frameLoader->activeDocumentLoader();
ic->identifierForInitialRequest(resourceId, loader, request.toResourceRequest());
}
}
bool SVGImage::dataChanged(bool allDataReceived)
{
// Don't do anything if is an empty image.
if (!data()->size())
return true;
if (allDataReceived) {
static FrameLoaderClient* dummyFrameLoaderClient = new EmptyFrameLoaderClient;
Page::PageClients pageClients;
m_chromeClient = adoptPtr(new SVGImageChromeClient(this));
pageClients.chromeClient = m_chromeClient.get();
#if ENABLE(CONTEXT_MENUS)
static ContextMenuClient* dummyContextMenuClient = new EmptyContextMenuClient;
pageClients.contextMenuClient = dummyContextMenuClient;
#endif
static EditorClient* dummyEditorClient = new EmptyEditorClient;
pageClients.editorClient = dummyEditorClient;
#if ENABLE(DRAG_SUPPORT)
static DragClient* dummyDragClient = new EmptyDragClient;
pageClients.dragClient = dummyDragClient;
#endif
static InspectorClient* dummyInspectorClient = new EmptyInspectorClient;
pageClients.inspectorClient = dummyInspectorClient;
#if ENABLE(DEVICE_ORIENTATION)
static DeviceMotionClient* dummyDeviceMotionClient = new EmptyDeviceMotionClient;
pageClients.deviceMotionClient = dummyDeviceMotionClient;
static DeviceOrientationClient* dummyDeviceOrientationClient = new EmptyDeviceOrientationClient;
pageClients.deviceOrientationClient = dummyDeviceOrientationClient;
#endif
// FIXME: If this SVG ends up loading itself, we might leak the world.
// The comment said that the Cache code does not know about CachedImages
// holding Frames and won't know to break the cycle. But
m_page.set(new Page(pageClients));
m_page->settings()->setMediaEnabled(false);
m_page->settings()->setJavaScriptEnabled(false);
m_page->settings()->setPluginsEnabled(false);
RefPtr<Frame> frame = Frame::create(m_page.get(), 0, dummyFrameLoaderClient);
frame->setView(FrameView::create(frame.get()));
frame->init();
ResourceRequest fakeRequest(KURL(ParsedURLString, ""));
FrameLoader* loader = frame->loader();
loader->setForcedSandboxFlags(SandboxAll);
loader->load(fakeRequest, false); // Make sure the DocumentLoader is created
loader->policyChecker()->cancelCheck(); // cancel any policy checks
loader->commitProvisionalLoad();
loader->writer()->setMIMEType("image/svg+xml");
loader->writer()->begin(KURL()); // create the empty document
loader->writer()->addData(data()->data(), data()->size());
loader->writer()->end();
frame->view()->setTransparent(true); // SVG Images are transparent.
}
return m_page;
}
// Cancels the data source's pending loads. Conceptually, a data source only loads
// one document at a time, but one document may have many related resources.
// stopLoading will stop all loads initiated by the data source,
// but not loads initiated by child frames' data sources -- that's the WebFrame's job.
void DocumentLoader::stopLoading(DatabasePolicy databasePolicy)
{
// In some rare cases, calling FrameLoader::stopLoading could set m_loading to false.
// (This can happen when there's a single XMLHttpRequest currently loading and stopLoading causes it
// to stop loading. Because of this, we need to save it so we don't return early.
bool loading = m_loading;
if (m_committed) {
// Attempt to stop the frame if the document loader is loading, or if it is done loading but
// still parsing. Failure to do so can cause a world leak.
Document* doc = m_frame->document();
if (loading || doc->parsing())
m_frame->loader()->stopLoading(UnloadEventPolicyNone, databasePolicy);
}
// Always cancel multipart loaders
cancelAll(m_multipartSubresourceLoaders);
// Appcache uses ResourceHandle directly, DocumentLoader doesn't count these loads.
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
m_applicationCacheHost->stopLoadingInFrame(m_frame);
#endif
if (!loading)
return;
RefPtr<Frame> protectFrame(m_frame);
RefPtr<DocumentLoader> protectLoader(this);
m_isStopping = true;
FrameLoader* frameLoader = DocumentLoader::frameLoader();
if (m_mainResourceLoader)
// Stop the main resource loader and let it send the cancelled message.
m_mainResourceLoader->cancel();
else if (!m_subresourceLoaders.isEmpty())
// The main resource loader already finished loading. Set the cancelled error on the
// document and let the subresourceLoaders send individual cancelled messages below.
setMainDocumentError(frameLoader->cancelledError(m_request));
else
// If there are no resource loaders, we need to manufacture a cancelled message.
// (A back/forward navigation has no resource loaders because its resources are cached.)
mainReceivedError(frameLoader->cancelledError(m_request), true);
stopLoadingSubresources();
stopLoadingPlugIns();
m_isStopping = false;
}
// We don't use m_url, or m_serviceType as they may not be the final values
// that <object> uses depending on <param> values.
bool HTMLPlugInImageElement::wouldLoadAsNetscapePlugin(const String& url, const String& serviceType)
{
ASSERT(document());
ASSERT(document()->frame());
KURL completedURL;
if (!url.isEmpty())
completedURL = document()->completeURL(url);
FrameLoader* frameLoader = document()->frame()->loader();
ASSERT(frameLoader);
if (frameLoader->client()->objectContentType(completedURL, serviceType, shouldPreferPlugInsForImages()) == ObjectContentNetscapePlugin)
return true;
return false;
}