ScriptPromise ServiceWorkerContainer::registerServiceWorker(ScriptState* scriptState, const String& url, const Dictionary& dictionary)
{
RegistrationOptionList options(dictionary);
ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled());
RefPtr<ScriptPromiseResolverWithContext> resolver = ScriptPromiseResolverWithContext::create(scriptState);
ScriptPromise promise = resolver->promise();
if (!m_provider) {
resolver->reject(DOMException::create(InvalidStateError, "No associated provider is available"));
return promise;
}
ExecutionContext* executionContext = scriptState->executionContext();
RefPtr<SecurityOrigin> documentOrigin = executionContext->securityOrigin();
KURL patternURL = executionContext->completeURL(options.scope);
patternURL.removeFragmentIdentifier();
if (!documentOrigin->canRequest(patternURL)) {
resolver->reject(DOMException::create(SecurityError, "Can only register for patterns in the document's origin."));
return promise;
}
KURL scriptURL = executionContext->completeURL(url);
scriptURL.removeFragmentIdentifier();
if (!documentOrigin->canRequest(scriptURL)) {
resolver->reject(DOMException::create(SecurityError, "Script must be in document's origin."));
return promise;
}
m_provider->registerServiceWorker(patternURL, scriptURL, new CallbackPromiseAdapter<ServiceWorker, ServiceWorkerError>(resolver));
return promise;
}
SoupURI* ResourceRequest::soupURI() const
{
// WebKit does not support fragment identifiers in data URLs, but soup does.
// Before passing the URL to soup, we should make sure to urlencode any '#'
// characters, so that soup does not interpret them as fragment identifiers.
// See http://wkbug.com/68089
if (m_url.protocolIsData()) {
String urlString = m_url.string();
urlString.replace("#", "%23");
return soup_uri_new(urlString.utf8().data());
}
KURL url = m_url;
url.removeFragmentIdentifier();
SoupURI* uri = soup_uri_new(url.string().utf8().data());
// Versions of libsoup prior to 2.42 have a soup_uri_new that will convert empty passwords that are not
// prefixed by a colon into null. Some parts of soup like the SoupAuthenticationManager will only be active
// when both the username and password are non-null. When we have credentials, empty usernames and passwords
// should be empty strings instead of null.
if (!url.user().isEmpty() || !url.pass().isEmpty()) {
soup_uri_set_user(uri, url.user().utf8().data());
soup_uri_set_password(uri, url.pass().utf8().data());
}
return uri;
}
KURL MemoryCache::removeFragmentIdentifierIfNeeded(const KURL& originalURL)
{
if (!originalURL.hasFragmentIdentifier())
return originalURL;
// Strip away fragment identifier from HTTP URLs.
// Data URLs must be unmodified. For file and custom URLs clients may expect resources
// to be unique even when they differ by the fragment identifier only.
if (!originalURL.protocolIsInHTTPFamily())
return originalURL;
KURL url = originalURL;
url.removeFragmentIdentifier();
return url;
}
/**
* webkit_download_get_suggested_filename:
* @download: the #WebKitDownload
*
* Retrieves the filename that was suggested by the server, or the one
* derived by WebKit from the URI.
*
* Returns: the suggested filename
*
* Since: 1.1.2
*/
const gchar* webkit_download_get_suggested_filename(WebKitDownload* download)
{
g_return_val_if_fail(WEBKIT_IS_DOWNLOAD(download), NULL);
WebKitDownloadPrivate* priv = download->priv;
if (priv->suggestedFilename)
return priv->suggestedFilename;
KURL url = KURL(KURL(), webkit_network_request_get_uri(priv->networkRequest));
url.setQuery(String());
url.removeFragmentIdentifier();
priv->suggestedFilename = g_strdup(decodeURLEscapeSequences(url.lastPathComponent()).utf8().data());
return priv->suggestedFilename;
}
void MediaPlayerPrivateGStreamer::setPlaybinURL(KURL& url)
{
// Clean out everything after file:// url path.
if (url.isLocalFile()) {
url.setQuery(String());
url.removeFragmentIdentifier();
}
m_url = url;
if (url.protocolIsInHTTPFamily())
url.setProtocol("webkit+" + url.protocol());
LOG_MEDIA_MESSAGE("Load %s", url.string().utf8().data());
g_object_set(m_playBin.get(), "uri", url.string().utf8().data(), NULL);
}
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
m_response = adoptGRef(response.toSoupMessage());
m_download->didReceiveResponse(response);
if (response.httpStatusCode() >= 400) {
downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url().string(), response.httpStatusText()));
return;
}
String suggestedFilename = response.suggestedFilename();
if (suggestedFilename.isEmpty()) {
KURL url = response.url();
url.setQuery(String());
url.removeFragmentIdentifier();
suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent());
}
bool overwrite;
String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename, overwrite);
if (destinationURI.isEmpty()) {
#if PLATFORM(GTK)
GOwnPtr<char> buffer(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data()));
String errorMessage = String::fromUTF8(buffer.get());
#else
String errorMessage = makeString("Cannot determine destination URI for download with suggested filename ", suggestedFilename);
#endif
downloadFailed(platformDownloadDestinationError(response, errorMessage));
return;
}
GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data()));
GOwnPtr<GError> error;
m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr()));
if (!m_outputStream) {
downloadFailed(platformDownloadDestinationError(response, error->message));
return;
}
GRefPtr<GFileInfo> info = adoptGRef(g_file_info_new());
g_file_info_set_attribute_string(info.get(), "metadata::download-uri", response.url().string().utf8().data());
g_file_set_attributes_async(file.get(), info.get(), G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, 0, 0, 0);
m_download->didCreateDestination(destinationURI);
}
static void openFileSystem(ScriptExecutionContext* context, const String& basePath, FileSystemType type, long long size, bool create, PassOwnPtr<AsyncFileSystemCallbacks> callbacks, FileSystemSynchronousType synchronousType)
{
ASSERT(context);
ASSERT(type != FileSystemTypeIsolated);
if (type == FileSystemTypeIsolated)
return;
KURL url = context->url();
if (url.hasFragmentIdentifier())
url.removeFragmentIdentifier();
url.setQuery(String());
url.setPath("/");
StringBuilder builder;
builder.append("filesystem:");
builder.append(url.string());
builder.append(fileSystemTypeString(type));
KURL rootURL = context->completeURL(builder.toString());
ASSERT(rootURL.isValid());
// TODO: Ask user for file system permission.
if (context->isDocument()) {
int playerId = 0;
Page* page = static_cast<Document*>(context)->page();
if (page)
playerId = page->chrome().client()->platformPageClient()->playerID();
AsyncFileSystemBlackBerry::openFileSystem(rootURL, basePath, context->securityOrigin()->databaseIdentifier(), type, size, create, playerId, callbacks);
} else {
#if ENABLE(WORKERS)
WorkerContext* workerContext = static_cast<WorkerContext*>(context);
String mode = openFileSystemMode;
mode.append(String::number(workerContext->thread()->runLoop().createUniqueId()));
WorkerAsyncFileSystemBlackBerry::openFileSystem(workerContext, rootURL, mode, basePath, context->securityOrigin()->databaseIdentifier(), type, size, create, callbacks);
if (synchronousType == SynchronousFileSystem)
workerContext->thread()->runLoop().runInMode(workerContext, mode);
#else
ASSERT_NOT_REACHED();
#endif
}
}
ScriptPromise ServiceWorkerContainer::unregisterServiceWorker(ScriptState* scriptState, const String& pattern)
{
ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled());
RefPtr<ScriptPromiseResolverWithContext> resolver = ScriptPromiseResolverWithContext::create(scriptState);
ScriptPromise promise = resolver->promise();
if (!m_provider) {
resolver->reject(DOMException::create(InvalidStateError, "No associated provider is available"));
return promise;
}
RefPtr<SecurityOrigin> documentOrigin = scriptState->executionContext()->securityOrigin();
KURL patternURL = scriptState->executionContext()->completeURL(pattern);
patternURL.removeFragmentIdentifier();
if (!pattern.isEmpty() && !documentOrigin->canRequest(patternURL)) {
resolver->reject(DOMException::create(SecurityError, "Can only unregister for patterns in the document's origin."));
return promise;
}
m_provider->unregisterServiceWorker(patternURL, new CallbackPromiseAdapter<UndefinedValue, ServiceWorkerError>(resolver));
return promise;
}
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
m_response = adoptGRef(response.toSoupMessage());
m_download->didReceiveResponse(response);
if (response.httpStatusCode() >= 400) {
downloadFailed(downloadNetworkError(ResourceError(errorDomainDownload, response.httpStatusCode(),
response.url().string(), response.httpStatusText())));
return;
}
String suggestedFilename = response.suggestedFilename();
if (suggestedFilename.isEmpty()) {
KURL url = response.url();
url.setQuery(String());
url.removeFragmentIdentifier();
suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent());
}
bool overwrite;
String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename.utf8().data(), overwrite);
if (destinationURI.isEmpty()) {
GOwnPtr<char> errorMessage(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"),
suggestedFilename.utf8().data()));
downloadFailed(downloadDestinationError(response, errorMessage.get()));
return;
}
GRefPtr<GFile> file = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data()));
GOwnPtr<GError> error;
m_outputStream = adoptGRef(g_file_replace(file.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr()));
if (!m_outputStream) {
downloadFailed(downloadDestinationError(response, error->message));
return;
}
m_download->didCreateDestination(destinationURI);
}
void ServiceWorkerLinkResource::process()
{
if (!m_owner || !m_owner->document().frame())
return;
if (!m_owner->shouldLoadLink())
return;
Document& document = m_owner->document();
KURL scriptURL = m_owner->href();
String scope = m_owner->scope();
KURL scopeURL;
if (scope.isNull())
scopeURL = KURL(scriptURL, "./");
else
scopeURL = document.completeURL(scope);
scopeURL.removeFragmentIdentifier();
TrackExceptionState exceptionState;
NavigatorServiceWorker::serviceWorker(&document, *document.frame()->domWindow()->navigator(), exceptionState)->registerServiceWorkerImpl(&document, scriptURL, scopeURL, wrapUnique(new RegistrationCallback(m_owner)));
}
KURL InspectorAgent::inspectedURLWithoutFragment() const
{
KURL url = inspectedURL();
url.removeFragmentIdentifier();
return url;
}