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; }