Notification::Notification(const KURL& url, ScriptExecutionContext* context, ExceptionCode& ec, PassRefPtr<NotificationCenter> provider)
: ActiveDOMObject(context, this)
, m_isHTML(true)
, m_state(Idle)
, m_notificationCenter(provider)
{
if (m_notificationCenter->checkPermission() != NotificationClient::PermissionAllowed) {
ec = SECURITY_ERR;
return;
}
if (url.isEmpty() || !url.isValid()) {
ec = SYNTAX_ERR;
return;
}
m_notificationURL = url;
}
void ChromeClient::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)
{
// check if the element is a link...
bool isLink = hit.isLiveLink();
if (isLink) {
KURL url = hit.absoluteLinkURL();
if (!url.isEmpty() && url != m_hoveredLinkURL) {
TextDirection dir;
CString titleString = hit.title(dir).utf8();
CString urlString = url.prettyURL().utf8();
g_signal_emit_by_name(m_webView, "hovering-over-link", titleString.data(), urlString.data());
m_hoveredLinkURL = url;
}
} else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
g_signal_emit_by_name(m_webView, "hovering-over-link", 0, 0);
m_hoveredLinkURL = KURL();
}
}
KURL::List CopyTo::copy(const KURL::List& sourceList, const KURL& destination )
{
m_listCopy = true;
m_destList.clear();
KURL targetDirURL = KURL();
if ( destination.isEmpty() )
{
targetDirURL = m_InitialDirUrl;
} else
{
targetDirURL = destination;
}
bool doCopy = true;
if (!QExtFileInfo::exists(targetDirURL, false, 0L))
{
doCopy = QExtFileInfo::createDir(targetDirURL, 0L);
}
KIO::UDSEntry entry;
if (doCopy)
{
QString path;
for (uint i = 0; i < sourceList.count(); i++)
{
KURL srcURL = sourceList[i];
KIO::NetAccess::stat(srcURL, entry, 0);
KFileItem item(entry, srcURL, false, true);
KURL u = targetDirURL;
u.setPath(targetDirURL.path(1) + srcURL.fileName());
if (item.isDir())
u.adjustPath(1);
path = u.path();
if (path != "." && path != "..")
m_destList.append(u);
}
KIO::CopyJob *job = KIO::copy(sourceList, targetDirURL, true);
connect( job, SIGNAL(result( KIO::Job *)),
SLOT (slotResult( KIO::Job *)));
}
return m_destList;
}
void subversionCore::blame( const KURL &url, UrlMode mode, int revstart, QString revKindStart, int revend, QString revKindEnd )
{
KURL servURL = m_part->baseURL();
if ( servURL.isEmpty() ) servURL="kdevsvn+svn://blah/";
if ( ! servURL.protocol().startsWith( "kdevsvn+" ) ) {
servURL.setProtocol( "kdevsvn+" + servURL.protocol() ); //make sure it starts with "svn"
}
kdDebug(9036) << "servURL : " << servURL.prettyURL() << endl;
QByteArray parms;
QDataStream s( parms, IO_WriteOnly );
// prepare arguments
int cmd = 14;
s << cmd << url << (int)mode ;
s << revstart << revKindStart << revend << revKindEnd ;
SimpleJob * job = KIO::special(servURL, parms, false);
connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotBlameResult( KIO::Job * ) ) );
initProcessDlg( (KIO::Job*)job, url.prettyURL() , i18n("Subversion Blame") );
}
void subversionCore::resolve( const KURL::List& list ) {
KURL servURL = m_part->baseURL();
if ( servURL.isEmpty() ) servURL="kdevsvn+svn://blah/";
if ( ! servURL.protocol().startsWith( "kdevsvn+" ) ) {
servURL.setProtocol( "kdevsvn+" + servURL.protocol() ); //make sure it starts with "svn"
}
kdDebug(9036) << "servURL : " << servURL.prettyURL() << endl;
for ( QValueListConstIterator<KURL> it = list.begin(); it != list.end() ; ++it ) {
kdDebug(9036) << "resolving: " << (*it).prettyURL() << endl;
QByteArray parms;
QDataStream s( parms, IO_WriteOnly );
int cmd = 11;
bool recurse = true;
s << cmd << *it << recurse;
SimpleJob * job = KIO::special(servURL, parms, true);
job->setWindow( m_part->mainWindow()->main() );
connect( job, SIGNAL( result( KIO::Job * ) ), this, SLOT( slotResult( KIO::Job * ) ) );
}
}
void HTMLPreloadScanner::scan(HTMLResourcePreloader* preloader, const KURL& startingBaseElementURL)
{
ASSERT(isMainThread()); // HTMLTokenizer::updateStateFor only works on the main thread.
// When we start scanning, our best prediction of the baseElementURL is the real one!
if (!startingBaseElementURL.isEmpty())
m_scanner.setPredictedBaseElementURL(startingBaseElementURL);
PreloadRequestStream requests;
while (m_tokenizer->nextToken(m_source, m_token)) {
if (m_token.type() == HTMLToken::StartTag)
m_tokenizer->updateStateFor(AtomicString(m_token.name()));
m_scanner.scan(m_token, requests);
m_token.clear();
}
preloader->takeAndPreload(requests);
}
void k2send::importPlaylist()
{
KURL url = KFileDialog::getOpenFileName (QString::null,"*.m3u",this, i18n("Import M3u playlist"));
if (!url.isEmpty()){
QFile file( url.path() );
if ( file.open( IO_ReadOnly ) ) {
QTextStream stream( &file );
QString line;
while ( !stream.atEnd() ) {
line = stream.readLine();
if (line[0] != '#')
m_view->slotAddFile(line);
kdDebug(200010) << "k2send::importPlaylist " << line << endl;
}
file.close();
}
}
}
Frame* createWindow(const String& urlString, const AtomicString& frameName, const WindowFeatures& windowFeatures,
DOMWindow* activeWindow, Frame* firstFrame, Frame* openerFrame, DOMWindow::PrepareDialogFunction function, void* functionContext)
{
Frame* activeFrame = activeWindow->frame();
KURL completedURL = urlString.isEmpty() ? KURL(ParsedURLString, emptyString()) : firstFrame->document()->completeURL(urlString);
if (!completedURL.isEmpty() && !completedURL.isValid()) {
// Don't expose client code to invalid URLs.
activeWindow->printErrorMessage("Unable to open a window with invalid URL '" + completedURL.string() + "'.\n");
return 0;
}
// For whatever reason, Firefox uses the first frame to determine the outgoingReferrer. We replicate that behavior here.
String referrer = SecurityPolicy::generateReferrerHeader(firstFrame->document()->referrerPolicy(), completedURL, firstFrame->loader()->outgoingReferrer());
ResourceRequest request(completedURL, referrer);
FrameLoader::addHTTPOriginIfNeeded(request, firstFrame->loader()->outgoingOrigin());
FrameLoadRequest frameRequest(activeWindow->document()->securityOrigin(), request, frameName);
// We pass the opener frame for the lookupFrame in case the active frame is different from
// the opener frame, and the name references a frame relative to the opener frame.
bool created;
Frame* newFrame = createWindow(activeFrame, openerFrame, frameRequest, windowFeatures, created);
if (!newFrame)
return 0;
newFrame->loader()->setOpener(openerFrame);
newFrame->page()->setOpenedByDOM();
if (newFrame->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
return newFrame;
if (function)
function(newFrame->domWindow(), functionContext);
if (created) {
FrameLoadRequest request(activeWindow->document()->securityOrigin(), ResourceRequest(completedURL, referrer));
newFrame->loader()->load(request);
} else if (!urlString.isEmpty()) {
newFrame->navigationScheduler()->scheduleLocationChange(activeWindow->document()->securityOrigin(), completedURL.string(), referrer, false);
}
return newFrame;
}
void RKWorkplace::openHelpWindow (const KURL &url, bool only_once) {
RK_TRACE (APP);
RKHelpWindow *hw = new RKHelpWindow (view ());
if (!url.isEmpty ()) {
if (only_once) {
RKWorkplaceObjectList help_windows = getObjectList (RKMDIWindow::HelpWindow, RKMDIWindow::AnyState);
for (RKWorkplaceObjectList::const_iterator it = help_windows.constBegin (); it != help_windows.constEnd (); ++it) {
if (static_cast<RKHelpWindow *> (*it)->url ().equals (url, true)) {
(*it)->activate ();
return;
}
}
}
hw->openURL (url);
}
addWindow (hw);
}
void KonqSidebarTree::slotExecuted( QListViewItem *item )
{
kdDebug(1201) << "KonqSidebarTree::slotExecuted " << item << endl;
if ( !item )
return;
if ( !static_cast<KonqSidebarTreeItem*>(item)->isClickable() )
return;
KonqSidebarTreeItem *dItem = static_cast<KonqSidebarTreeItem *>( item );
KParts::URLArgs args;
args.serviceType = dItem->externalMimeType();
args.trustedSource = true;
KURL externalURL = dItem->externalURL();
if ( !externalURL.isEmpty() )
openURLRequest( externalURL, args );
}
void HTMLVideoElement::setDisplayMode(DisplayMode mode)
{
DisplayMode oldMode = getDisplayMode();
KURL poster = posterImageURL();
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.
// Don't show the poster if there is a seek operation or
// the video has restarted because of loop attribute
if (mode == Video && oldMode == Poster && !hasAvailableVideoFrame())
return;
}
HTMLMediaElement::setDisplayMode(mode);
if (layoutObject() && getDisplayMode() != oldMode)
layoutObject()->updateFromElement();
}
static bool writeURL(WCDataObject *data, const KURL& url, String title, bool withPlainText, bool withHTML)
{
ASSERT(data);
if (url.isEmpty())
return false;
if (title.isEmpty()) {
title = url.lastPathComponent();
if (title.isEmpty())
title = url.host();
}
STGMEDIUM medium = {0};
medium.tymed = TYMED_HGLOBAL;
medium.hGlobal = createGlobalData(url, title);
bool success = false;
if (medium.hGlobal && FAILED(data->SetData(urlWFormat(), &medium, TRUE)))
::GlobalFree(medium.hGlobal);
else
success = true;
if (withHTML) {
Vector<char> cfhtmlData;
markupToCF_HTML(urlToMarkup(url, title), "", cfhtmlData);
medium.hGlobal = createGlobalData(cfhtmlData);
if (medium.hGlobal && FAILED(data->SetData(htmlFormat(), &medium, TRUE)))
::GlobalFree(medium.hGlobal);
else
success = true;
}
if (withPlainText) {
medium.hGlobal = createGlobalData(url.string());
if (medium.hGlobal && FAILED(data->SetData(plainTextWFormat(), &medium, TRUE)))
::GlobalFree(medium.hGlobal);
else
success = true;
}
return success;
}
WebKitNotification::WebKitNotification(const String& title, const String& body, const String& iconUrl, ExecutionContext* context, ExceptionState& es, PassRefPtr<NotificationCenter> provider)
: NotificationBase(title, context, provider->client())
{
ScriptWrappable::init(this);
if (provider->checkPermission() != NotificationClient::PermissionAllowed) {
es.throwSecurityError("Notification permission has not been granted.");
return;
}
KURL icon = iconUrl.isEmpty() ? KURL() : executionContext()->completeURL(iconUrl);
if (!icon.isEmpty() && !icon.isValid()) {
es.throwDOMException(SyntaxError, "'" + iconUrl + "' is not a valid icon URL.");
return;
}
setBody(body);
setIconUrl(icon);
}
void KJumpingCube::openGame()
{
bool fileOk=true;
KURL url;
do
{
url = KFileDialog::getOpenURL( gameURL.url(), "*.kjc", this, 0 );
if( url.isEmpty() )
return;
if(!KIO::NetAccess::exists(url,true,this))
{
QString mes=i18n("The file %1 does not exist!").arg(url.url());
KMessageBox::sorry(this,mes);
fileOk=false;
}
}
while(!fileOk);
QString tempFile;
if( KIO::NetAccess::download( url, tempFile, this ) )
{
KSimpleConfig config(tempFile,true);
config.setGroup("KJumpingCube");
if(!config.hasKey("Version"))
{
QString mes=i18n("The file %1 isn't a KJumpingCube gamefile!")
.arg(url.url());
KMessageBox::sorry(this,mes);
return;
}
gameURL=url;
config.setGroup("Game");
view->restoreGame(&config);
undoAction->setEnabled(false);
KIO::NetAccess::removeTempFile( tempFile );
}
else
KMessageBox::sorry(this,i18n("There was an error loading file\n%1").arg( url.url() ));
}
static void logCanCachePageDecision(Page* page)
{
// Only bother logging for main frames that have actually loaded and have content.
if (page->mainFrame()->loader()->creatingInitialEmptyDocument())
return;
KURL currentURL = page->mainFrame()->loader()->documentLoader() ? page->mainFrame()->loader()->documentLoader()->url() : KURL();
if (currentURL.isEmpty())
return;
int indentLevel = 0;
PCLOG("--------\n Determining if page can be cached:");
bool cannotCache = !logCanCacheFrameDecision(page->mainFrame(), 1);
FrameLoadType loadType = page->mainFrame()->loader()->loadType();
if (!page->backForwardList()->enabled()) {
PCLOG(" -The back/forward list is disabled");
cannotCache = true;
}
if (!(page->backForwardList()->capacity() > 0)) {
PCLOG(" -The back/forward list has a 0 capacity");
cannotCache = true;
}
if (!page->settings()->usesPageCache()) {
PCLOG(" -Page settings says b/f cache disabled");
cannotCache = true;
}
if (loadType == FrameLoadTypeReload) {
PCLOG(" -Load type is: Reload");
cannotCache = true;
}
if (loadType == FrameLoadTypeReloadFromOrigin) {
PCLOG(" -Load type is: Reload from origin");
cannotCache = true;
}
if (loadType == FrameLoadTypeSame) {
PCLOG(" -Load type is: Same");
cannotCache = true;
}
PCLOG(cannotCache ? " Page CANNOT be cached\n--------" : " Page CAN be cached\n--------");
}
void LinkLoader::preloadIfNeeded(const LinkRelAttribute& relAttribute, const KURL& href, Document& document, const String& as)
{
if (relAttribute.isLinkPreload()) {
ASSERT(RuntimeEnabledFeatures::linkPreloadEnabled());
if (!href.isValid() || href.isEmpty()) {
document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, WarningMessageLevel, String("<link rel=preload> has an invalid `href` value")));
return;
}
Resource::Type type;
if (!getTypeFromAsAttribute(as, type)) {
document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, WarningMessageLevel, String("<link rel=preload> must have a valid `as` value")));
return;
}
FetchRequest linkRequest(ResourceRequest(document.completeURL(href)), FetchInitiatorTypeNames::link);
Settings* settings = document.settings();
if (settings && settings->logPreload())
document.addConsoleMessage(ConsoleMessage::create(OtherMessageSource, DebugMessageLevel, String("Preload triggered for " + href.host() + href.path())));
setResource(document.fetcher()->fetchLinkPreloadResource(type, linkRequest));
}
}
void Editor::loadBoard() {
if ( !testSave() )
return;
KURL url = KFileDialog::getOpenURL(
NULL,
i18n("*.layout|Board Layout (*.layout)\n"
"*|All Files"),
this,
i18n("Open Board Layout" ));
if ( url.isEmpty() )
return;
theBoard.loadBoardLayout( url.path() );
repaint(false);
}
bool InProcessWorkerBase::initialize(ExecutionContext* context, const String& url, ExceptionState& exceptionState)
{
suspendIfNeeded();
KURL scriptURL = resolveURL(url, exceptionState);
if (scriptURL.isEmpty())
return false;
m_scriptLoader = WorkerScriptLoader::create();
m_scriptLoader->loadAsynchronously(
*context,
scriptURL,
DenyCrossOriginRequests,
bind(&InProcessWorkerBase::onResponse, this),
bind(&InProcessWorkerBase::onFinished, this));
m_contextProxy = createWorkerGlobalScopeProxy(context);
return true;
}
Notification::Notification(const NotificationContents& contents, ScriptExecutionContext* context, ExceptionCode& ec, NotificationPresenter* provider)
: ActiveDOMObject(context, this)
, m_isHTML(false)
, m_contents(contents)
, m_isShowing(false)
, m_presenter(provider)
{
ASSERT(m_presenter);
Document* document = context->isDocument() ? static_cast<Document*>(context) : 0;
if (m_presenter->checkPermission(context->url(), document) != NotificationPresenter::PermissionAllowed) {
ec = SECURITY_ERR;
return;
}
KURL icon = context->completeURL(contents.icon());
if (!icon.isEmpty() && !icon.isValid()) {
ec = SYNTAX_ERR;
return;
}
}
bool SubframeLoader::requestFrame(HTMLFrameOwnerElement* ownerElement, const String& urlString, const AtomicString& frameName, bool lockHistory, bool lockBackForwardList)
{
// Support for <frame src="javascript:string">
KURL scriptURL;
KURL url;
if (protocolIsJavaScript(urlString)) {
scriptURL = completeURL(urlString); // completeURL() encodes the URL.
url = blankURL();
} else
url = completeURL(urlString);
Frame* frame = loadOrRedirectSubframe(ownerElement, url, frameName, lockHistory, lockBackForwardList);
if (!frame)
return false;
if (!scriptURL.isEmpty())
frame->script()->executeIfJavaScriptURL(scriptURL);
return true;
}
KURL CopyTo::copy(const KURL& urlToCopy, const KURL& destination)
{
m_destList.clear();
KURL targetDirURL = KURL();
if ( destination.isEmpty() )
{
targetDirURL = m_InitialDirUrl;
} else
{
targetDirURL = destination;
}
targetDirURL.adjustPath(1);
bool doCopy = true;
if (!QExtFileInfo::exists(targetDirURL, false, 0L))
{
doCopy = QExtFileInfo::createDir(targetDirURL, 0L);
}
KURL destURL;
if (doCopy)
{
KIO::UDSEntry entry;
KIO::NetAccess::stat(urlToCopy, entry, 0);
KFileItem item(entry, urlToCopy, false, true);
destURL = targetDirURL;
destURL.setPath(destURL.path(1) + urlToCopy.fileName(false));
if (item.isDir())
destURL.adjustPath(1);
KIO::CopyJob *job = KIO::copy(urlToCopy, destURL, true);
connect( job, SIGNAL(result( KIO::Job *)),
SLOT (slotResult( KIO::Job *)));
QString path = destURL.path();
if (path != "." && path != "..")
m_destList.append(destURL);
}
return destURL;
}
PassRefPtr<Worker> Worker::create(const String& url, ScriptExecutionContext* context, ExceptionCode& ec)
{
RefPtr<Worker> worker = adoptRef(new Worker(context));
KURL scriptURL = worker->resolveURL(url, ec);
if (scriptURL.isEmpty())
return 0;
worker->m_scriptLoader = adoptPtr(new WorkerScriptLoader(ResourceRequestBase::TargetIsWorker));
worker->m_scriptLoader->loadAsynchronously(context, scriptURL, DenyCrossOriginRequests, worker.get());
// The worker context does not exist while loading, so we must ensure that the worker object is not collected, nor are its event listeners.
worker->setPendingActivity(worker.get());
#if ENABLE(INSPECTOR)
if (InspectorController* inspector = context->inspectorController())
inspector->didCreateWorker(worker->asID(), scriptURL.string(), false);
#endif
return worker.release();
}
void Pasteboard::writeURL(const KURL& url, const String& label, Frame* frame)
{
if (url.isEmpty())
return;
GtkClipboard* clipboard = PasteboardHelper::clipboardForFrame(frame);
ASSERT(clipboard);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
ASSERT(dataObject);
String actualLabel(label);
if (actualLabel.isEmpty())
actualLabel = url;
Vector<KURL> uriList;
uriList.append(url);
dataObject->setURIList(uriList);
dataObject->setText(actualLabel);
PasteboardHelper::helper()->writeClipboardContents(clipboard);
}
void IconLoader::finishLoading(const KURL& iconURL, PassRefPtr<SharedBuffer> data)
{
// When an icon load results in a 404 we commit it to the database here and clear the loading state.
// But the SubresourceLoader continues pulling in data in the background for the 404 page if the server sends one.
// Once that data finishes loading or if the load is cancelled while that data is being read, finishLoading ends up being called a second time.
// We need to change SubresourceLoader to have a mode where it will stop itself after receiving a 404 so this won't happen -
// in the meantime, we'll only commit this data to the IconDatabase if it's the first time ::finishLoading() is called
// <rdar://problem/5463392> tracks that enhancement
if (!iconURL.isEmpty() && m_loadIsInProgress) {
LOG(IconDatabase, "IconLoader::finishLoading() - Committing iconURL %s to database", iconURL.string().ascii().data());
m_frame->loader()->commitIconURLToIconDatabase(iconURL);
// Setting the icon data only after committing to the database ensures that the data is
// kept in memory (so it does not have to be read from the database asynchronously), since
// there is a page URL referencing it.
iconDatabase().setIconDataForIconURL(data, iconURL.string());
m_frame->loader()->client()->dispatchDidReceiveIcon();
}
clearLoadingState();
}
PassRefPtr<SharedWorker> SharedWorker::create(ScriptExecutionContext* context, const String& url, const String& name, ExceptionCode& ec)
{
RefPtr<SharedWorker> worker = adoptRef(new SharedWorker(context));
RefPtr<MessageChannel> channel = MessageChannel::create(context);
worker->m_port = channel->port1();
OwnPtr<MessagePortChannel> remotePort = channel->port2()->disentangle(ec);
ASSERT(remotePort);
worker->suspendIfNeeded();
KURL scriptURL = worker->resolveURL(url, ec);
if (scriptURL.isEmpty())
return 0;
SharedWorkerRepository::connect(worker.get(), remotePort.release(), scriptURL, name, ec);
InspectorInstrumentation::didCreateWorker(context, worker->asID(), scriptURL.string(), true);
return worker.release();
}
PassRefPtr<Notification> Notification::create(ScriptExecutionContext* context, const String& title, const Dictionary& options)
{
RefPtr<Notification> notification(adoptRef(new Notification(context, title)));
String argument;
if (options.get("body", argument))
notification->setBody(argument);
if (options.get("tag", argument))
notification->setTag(argument);
if (options.get("lang", argument))
notification->setLang(argument);
if (options.get("dir", argument))
notification->setDir(argument);
if (options.get("icon", argument)) {
KURL iconURI = argument.isEmpty() ? KURL() : context->completeURL(argument);
if (!iconURI.isEmpty() && iconURI.isValid())
notification->setIconURL(iconURI);
}
notification->suspendIfNeeded();
return notification.release();
}
PassRefPtr<Worker> Worker::create(ScriptExecutionContext* context, const String& url, ExceptionState& es)
{
ASSERT(isMainThread());
UseCounter::count(toDocument(context)->domWindow(), UseCounter::WorkerStart);
RefPtr<Worker> worker = adoptRef(new Worker(context));
worker->suspendIfNeeded();
KURL scriptURL = worker->resolveURL(url, es);
if (scriptURL.isEmpty())
return 0;
// The worker context does not exist while loading, so we must ensure that the worker object is not collected, nor are its event listeners.
worker->setPendingActivity(worker.get());
worker->m_scriptLoader = WorkerScriptLoader::create();
worker->m_scriptLoader->loadAsynchronously(context, scriptURL, DenyCrossOriginRequests, worker.get());
return worker.release();
}
PassRefPtr<Worker> Worker::create(ScriptExecutionContext* context, const String& url, ExceptionCode& ec)
{
RefPtr<Worker> worker = adoptRef(new Worker(context));
KURL scriptURL = worker->resolveURL(url, ec);
if (scriptURL.isEmpty())
return 0;
// The worker context does not exist while loading, so we must ensure that the worker object is not collected, nor are its event listeners.
worker->setPendingActivity(worker.get());
worker->m_scriptLoader = WorkerScriptLoader::create();
#if PLATFORM(CHROMIUM)
worker->m_scriptLoader->setTargetType(ResourceRequest::TargetIsWorker);
#endif
worker->m_scriptLoader->loadAsynchronously(context, scriptURL, DenyCrossOriginRequests, worker.get());
InspectorInstrumentation::didCreateWorker(context, worker->asID(), scriptURL.string(), false);
return worker.release();
}
bool HTMLTrackElement::canLoadUrl(const KURL& url)
{
HTMLMediaElement* parent = mediaElement();
if (!parent)
return false;
// 4.8.10.12.3 Sourcing out-of-band text tracks
// 4. Download: If URL is not the empty string, perform a potentially CORS-enabled fetch of URL, with the
// mode being the state of the media element's crossorigin content attribute, the origin being the
// origin of the media element's Document, and the default origin behaviour set to fail.
if (url.isEmpty())
return false;
if (!document().contentSecurityPolicy()->allowMediaFromSource(url)) {
WTF_LOG(Media, "HTMLTrackElement::canLoadUrl(%s) -> rejected by Content Security Policy", urlForLoggingTrack(url).utf8().data());
return false;
}
return true;
}
void ChromeClientEfl::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)
{
// FIXME, compare with old link, look at Qt impl.
bool isLink = hit.isLiveLink();
if (isLink) {
KURL url = hit.absoluteLinkURL();
if (!url.isEmpty() && url != m_hoveredLinkURL) {
const char* link[2];
TextDirection dir;
CString urlStr = url.string().utf8();
CString titleStr = hit.title(dir).utf8();
link[0] = urlStr.data();
link[1] = titleStr.data();
ewk_view_mouse_link_hover_in(m_view, link);
m_hoveredLinkURL = url;
}
} else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
ewk_view_mouse_link_hover_out(m_view);
m_hoveredLinkURL = KURL();
}
}