ScriptPromise FontFaceSet::load(ScriptState* scriptState, const String& fontString, const String& text) { if (!inActiveDocumentContext()) return ScriptPromise(); Font font; if (!resolveFontStyle(fontString, font)) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); resolver->reject(DOMException::create(SyntaxError, "Could not resolve '" + fontString + "' as a font.")); return promise; } FontFaceCache* fontFaceCache = document()->styleEngine()->fontSelector()->fontFaceCache(); FontFaceArray faces; for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) { CSSSegmentedFontFace* segmentedFontFace = fontFaceCache->get(font.fontDescription(), f->family()); if (segmentedFontFace) segmentedFontFace->match(nullToSpace(text), faces); } RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, scriptState); ScriptPromise promise = resolver->promise(); resolver->loadFonts(executionContext()); // After this, resolver->promise() may return null. return promise; }
ScriptPromise SubtleCrypto::wrapKey(ScriptState* scriptState, const String& rawFormat, Key* key, Key* wrappingKey, const Dictionary& rawWrapAlgorithm) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; if (!ensureNotNull(key, "key", result.get())) return promise; if (!ensureNotNull(wrappingKey, "wrappingKey", result.get())) return promise; blink::WebCryptoKeyFormat format; if (!Key::parseFormat(rawFormat, format, result.get())) return promise; blink::WebCryptoAlgorithm wrapAlgorithm; if (!parseAlgorithm(rawWrapAlgorithm, blink::WebCryptoOperationWrapKey, wrapAlgorithm, result.get())) return promise; if (!key->extractable()) { result->completeWithError(blink::WebCryptoErrorTypeInvalidAccess, "key is not extractable"); return promise; } if (!wrappingKey->canBeUsedForAlgorithm(wrapAlgorithm, blink::WebCryptoOperationWrapKey, result.get())) return promise; blink::Platform::current()->crypto()->wrapKey(format, key->key(), wrappingKey->key(), wrapAlgorithm, result->result()); return promise; }
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; }
JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 2) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto keyFormat = cryptoKeyFormatFromJSValue(state, scope, state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(1)); if (!key) return throwTypeError(&state, scope); RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable { fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size()); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; WebCore::exportKey(state, keyFormat, *key, WTFMove(successCallback), WTFMove(failureCallback)); RETURN_IF_EXCEPTION(scope, JSValue()); return promise; }
ScriptPromise Presentation::joinSession(ScriptState* state, const String& senderId, const String& presentationId) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(state); ScriptPromise promise = resolver->promise(); resolver->reject(DOMException::create(NotSupportedError, "The method is not supported yet.")); return promise; }
ScriptPromise SubtleCrypto::importKey(const String& rawFormat, ArrayBufferView* keyData, const Dictionary& rawAlgorithm, bool extractable, const Vector<String>& rawKeyUsages, ExceptionState& es) { WebKit::WebCryptoKeyFormat format; if (!Key::parseFormat(rawFormat, format, es)) return ScriptPromise(); if (!keyData) { es.throwTypeError("Invalid keyData argument"); return ScriptPromise(); } WebKit::WebCryptoKeyUsageMask keyUsages; if (!Key::parseUsageMask(rawKeyUsages, keyUsages, es)) return ScriptPromise(); WebKit::WebCryptoAlgorithm algorithm; if (!normalizeAlgorithm(rawAlgorithm, ImportKey, algorithm, es)) return ScriptPromise(); const unsigned char* keyDataBytes = static_cast<unsigned char*>(keyData->baseAddress()); RefPtr<CryptoResult> result = CryptoResult::create(); WebKit::Platform::current()->crypto()->importKey(format, keyDataBytes, keyData->byteLength(), algorithm, extractable, keyUsages, result->result()); return result->promise(); }
JSValue JSWebKitSubtleCrypto::digest(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 2) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); auto parameters = JSCryptoAlgorithmDictionary::createParametersForDigest(state, scope, algorithm->identifier(), state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); auto data = cryptoOperationDataFromJSValue(state, scope, state.uncheckedArgument(1)); RETURN_IF_EXCEPTION(scope, { }); RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable { fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size()); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; auto result = algorithm->digest(*parameters, data, WTFMove(successCallback), WTFMove(failureCallback)); if (result.hasException()) { propagateException(state, scope, result.releaseException()); return { }; } return promise; }
ScriptPromise SubtleCrypto::unwrapKey(ScriptState* scriptState, const String& rawFormat, const ArrayPiece& wrappedKey, Key* unwrappingKey, const Dictionary& rawUnwrapAlgorithm, const Dictionary& rawUnwrappedKeyAlgorithm, bool extractable, const Vector<String>& rawKeyUsages) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; if (!ensureNotNull(wrappedKey, "wrappedKey", result.get())) return promise; if (!ensureNotNull(unwrappingKey, "unwrappingKey", result.get())) return promise; blink::WebCryptoKeyFormat format; if (!Key::parseFormat(rawFormat, format, result.get())) return promise; blink::WebCryptoKeyUsageMask keyUsages; if (!Key::parseUsageMask(rawKeyUsages, keyUsages, result.get())) return promise; blink::WebCryptoAlgorithm unwrapAlgorithm; if (!parseAlgorithm(rawUnwrapAlgorithm, blink::WebCryptoOperationUnwrapKey, unwrapAlgorithm, result.get())) return promise; blink::WebCryptoAlgorithm unwrappedKeyAlgorithm; if (!parseAlgorithm(rawUnwrappedKeyAlgorithm, blink::WebCryptoOperationImportKey, unwrappedKeyAlgorithm, result.get())) return promise; if (!unwrappingKey->canBeUsedForAlgorithm(unwrapAlgorithm, blink::WebCryptoOperationUnwrapKey, result.get())) return promise; blink::Platform::current()->crypto()->unwrapKey(format, wrappedKey.bytes(), wrappedKey.byteLength(), unwrappingKey->key(), unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, result->result()); return promise; }
ScriptPromise SubtleCrypto::importKey(ScriptState* scriptState, const String& rawFormat, const Dictionary& keyData, const Dictionary& rawAlgorithm, bool extractable, const Vector<String>& rawKeyUsages) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; blink::WebCryptoKeyFormat format; if (!Key::parseFormat(rawFormat, format, result.get())) return promise; blink::WebCryptoKeyUsageMask keyUsages; if (!Key::parseUsageMask(rawKeyUsages, keyUsages, result.get())) return promise; if (format != blink::WebCryptoKeyFormatJwk) { result->completeWithError(blink::WebCryptoErrorTypeData, "Key data must be a buffer for non-JWK formats"); return promise; } blink::WebCryptoAlgorithm algorithm; if (!parseAlgorithm(rawAlgorithm, blink::WebCryptoOperationImportKey, algorithm, result.get())) return promise; CString jsonUtf8; if (!copyJwkDictionaryToJson(keyData, jsonUtf8, result.get())) return promise; blink::Platform::current()->crypto()->importKey(format, reinterpret_cast<const unsigned char*>(jsonUtf8.data()), jsonUtf8.length(), algorithm, extractable, keyUsages, result->result()); return promise; }
ScriptPromise SubtleCrypto::deriveKey(ScriptState* scriptState, const AlgorithmIdentifier& rawAlgorithm, CryptoKey* baseKey, const AlgorithmIdentifier& rawDerivedKeyType, bool extractable, const Vector<String>& rawKeyUsages) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; WebCryptoKeyUsageMask keyUsages; if (!CryptoKey::parseUsageMask(rawKeyUsages, keyUsages, result.get())) return promise; WebCryptoAlgorithm algorithm; if (!parseAlgorithm(rawAlgorithm, WebCryptoOperationDeriveBits, algorithm, result.get())) return promise; if (!baseKey->canBeUsedForAlgorithm(algorithm, WebCryptoKeyUsageDeriveKey, result.get())) return promise; WebCryptoAlgorithm importAlgorithm; if (!parseAlgorithm(rawDerivedKeyType, WebCryptoOperationImportKey, importAlgorithm, result.get())) return promise; WebCryptoAlgorithm keyLengthAlgorithm; if (!parseAlgorithm(rawDerivedKeyType, WebCryptoOperationGetKeyLength, keyLengthAlgorithm, result.get())) return promise; histogramAlgorithmAndKey(scriptState->executionContext(), algorithm, baseKey->key()); histogramAlgorithm(scriptState->executionContext(), importAlgorithm); Platform::current()->crypto()->deriveKey(algorithm, baseKey->key(), importAlgorithm, keyLengthAlgorithm, extractable, keyUsages, result->result()); return promise; }
ScriptPromise SubtleCrypto::importKey(ScriptState* scriptState, const String& rawFormat, const ArrayPiece& keyData, const Dictionary& rawAlgorithm, bool extractable, const Vector<String>& rawKeyUsages) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; if (!ensureNotNull(keyData, "keyData", result.get())) return promise; blink::WebCryptoKeyFormat format; if (!Key::parseFormat(rawFormat, format, result.get())) return promise; if (format == blink::WebCryptoKeyFormatJwk) { result->completeWithError(blink::WebCryptoErrorTypeData, "Key data must be an object for JWK import"); return promise; } blink::WebCryptoKeyUsageMask keyUsages; if (!Key::parseUsageMask(rawKeyUsages, keyUsages, result.get())) return promise; blink::WebCryptoAlgorithm algorithm; if (!parseAlgorithm(rawAlgorithm, blink::WebCryptoOperationImportKey, algorithm, result.get())) return promise; blink::Platform::current()->crypto()->importKey(format, keyData.bytes(), keyData.byteLength(), algorithm, extractable, keyUsages, result->result()); return promise; }
ScriptPromise Cache::keysImpl(ScriptState* scriptState) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); const ScriptPromise promise = resolver->promise(); m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, WebServiceWorkerCache::QueryParams()); return promise; }
ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, Response* response) { KURL url(KURL(), request->url()); if (!url.protocolIsInHTTPFamily()) return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request scheme '" + url.protocol() + "' is unsupported")); if (request->method() != "GET") return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request method '" + request->method() + "' is unsupported")); if (request->hasBody() && request->bodyUsed()) return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request body is already used")); if (response->hasBody() && response->bodyUsed()) return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Response body is already used")); if (request->hasBody()) request->setBodyUsed(); if (response->hasBody()) response->setBodyUsed(); WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1)); batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut; request->populateWebServiceWorkerRequest(batchOperations[0].request); response->populateWebServiceWorkerResponse(batchOperations[0].response); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); const ScriptPromise promise = resolver->promise(); m_webCache->dispatchBatch(new CacheAddOrPutCallbacks(resolver), batchOperations); return promise; }
void MediaEndpointPeerConnection::createOffer(RTCOfferOptions& options, SessionDescriptionPromise&& promise) { const RefPtr<RTCOfferOptions> protectedOptions = &options; RefPtr<WrappedSessionDescriptionPromise> wrappedPromise = WrappedSessionDescriptionPromise::create(WTFMove(promise)); runTask([this, protectedOptions, wrappedPromise]() { createOfferTask(*protectedOptions, wrappedPromise->promise()); }); }
ScriptPromise ScriptPromise::reject(ScriptState* scriptState, v8::Handle<v8::Value> value) { if (value.IsEmpty()) return ScriptPromise(); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); resolver->reject(value); return promise; }
JSValue JSWebKitSubtleCrypto::verify(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 4) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto algorithm = createAlgorithmFromJSValue(state, state.uncheckedArgument(0)); ASSERT(scope.exception() || algorithm); if (!algorithm) return jsUndefined(); auto parameters = JSCryptoAlgorithmDictionary::createParametersForVerify(&state, algorithm->identifier(), state.uncheckedArgument(0)); ASSERT(scope.exception() || parameters); if (!parameters) return jsUndefined(); RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(state.uncheckedArgument(1)); if (!key) return throwTypeError(&state, scope); if (!key->allows(CryptoKeyUsageVerify)) { wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'verify'")); setDOMException(&state, NOT_SUPPORTED_ERR); return jsUndefined(); } CryptoOperationData signature; auto success = cryptoOperationDataFromJSValue(&state, state.uncheckedArgument(2), signature); ASSERT(scope.exception() || success); if (!success) return jsUndefined(); CryptoOperationData data; success = cryptoOperationDataFromJSValue(&state, state.uncheckedArgument(3), data); ASSERT(scope.exception() || success); if (!success) return jsUndefined(); RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](bool result) mutable { wrapper->resolve(result); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(nullptr); }; auto result = algorithm->verify(*parameters, *key, signature, data, WTFMove(successCallback), WTFMove(failureCallback)); if (result.hasException()) { propagateException(state, scope, result.releaseException()); return { }; } return promise; }
JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 4) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto keyFormat = cryptoKeyFormatFromJSValue(state, scope, state.uncheckedArgument(0)); RETURN_IF_EXCEPTION(scope, { }); RefPtr<CryptoKey> key = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(1)); if (!key) return throwTypeError(&state, scope); RefPtr<CryptoKey> wrappingKey = JSCryptoKey::toWrapped(vm, state.uncheckedArgument(2)); if (!key) return throwTypeError(&state, scope); if (!wrappingKey->allows(CryptoKeyUsageWrapKey)) { wrapped().document()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, ASCIILiteral("Key usages do not include 'wrapKey'")); throwNotSupportedError(state, scope); return jsUndefined(); } auto algorithm = createAlgorithmFromJSValue(state, scope, state.uncheckedArgument(3)); RETURN_IF_EXCEPTION(scope, { }); auto parameters = JSCryptoAlgorithmDictionary::createParametersForEncrypt(state, scope, algorithm->identifier(), state.uncheckedArgument(3)); RETURN_IF_EXCEPTION(scope, { }); RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable { auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable { fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), encryptedData.data(), encryptedData.size()); }; auto encryptFailureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; auto result = algorithm->encryptForWrapKey(*parameters, *wrappingKey, std::make_pair(exportedKeyData.data(), exportedKeyData.size()), WTFMove(encryptSuccessCallback), WTFMove(encryptFailureCallback)); if (result.hasException()) { // FIXME: Report failure details to console, and possibly to calling script once there is a standardized way to pass errors to WebCrypto promise reject functions. wrapper->reject(); // FIXME: This should reject with an Exception. } }; auto exportFailureCallback = [wrapper]() mutable { wrapper->reject(); // FIXME: This should reject with an Exception. }; WebCore::exportKey(state, keyFormat, *key, WTFMove(exportSuccessCallback), WTFMove(exportFailureCallback)); return promise; }
ScriptPromise FetchManager::fetch(ScriptState* scriptState, const FetchRequestData* request) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); OwnPtr<Loader> ownLoader(adoptPtr(new Loader(m_executionContext, this, resolver.release(), request))); Loader* loader = m_loaders.add(ownLoader.release()).storedValue->get(); loader->start(); return promise; }
ScriptPromise Cache::keysImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options) { WebServiceWorkerRequest webRequest; request->populateWebServiceWorkerRequest(webRequest); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); const ScriptPromise promise = resolver->promise(); m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options)); return promise; }
ScriptPromise Cache::ready(ScriptState* scriptState) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); // FIXME: Implement. notImplemented(); resolver->reject(DOMError::create(NotSupportedError)); return promise; }
ScriptPromise InstallEvent::reloadAll(ScriptState* scriptState) { // FIXME: implement. notImplemented(); // For now this just returns a promise which is already rejected. RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); resolver->reject(ScriptValue(scriptState, v8::Null(scriptState->isolate()))); return promise; }
JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) { VM& vm = state.vm(); auto scope = DECLARE_THROW_SCOPE(vm); if (state.argumentCount() < 1) return throwException(&state, scope, createNotEnoughArgumentsError(&state)); auto algorithm = createAlgorithmFromJSValue(state, state.uncheckedArgument(0)); ASSERT(scope.exception() || algorithm); if (!algorithm) return jsUndefined(); auto parameters = JSCryptoAlgorithmDictionary::createParametersForGenerateKey(&state, algorithm->identifier(), state.uncheckedArgument(0)); ASSERT(scope.exception() || parameters); if (!parameters) return jsUndefined(); bool extractable = false; if (state.argumentCount() >= 2) { extractable = state.uncheckedArgument(1).toBoolean(&state); RETURN_IF_EXCEPTION(scope, JSValue()); } CryptoKeyUsageBitmap keyUsages = 0; if (state.argumentCount() >= 3) { auto success = cryptoKeyUsagesFromJSValue(state, state.argument(2), keyUsages); ASSERT(scope.exception() || success); if (!success) return jsUndefined(); } RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow()); auto promise = wrapper->promise(); auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable { ASSERT(key || keyPair); ASSERT(!key || !keyPair); if (key) wrapper->resolve(key); else wrapper->resolve(keyPair); }; auto failureCallback = [wrapper]() mutable { wrapper->reject(nullptr); }; auto result = algorithm->generateKey(*parameters, extractable, keyUsages, WTFMove(successCallback), WTFMove(failureCallback), *scriptExecutionContextFromExecState(&state)); if (result.hasException()) { propagateException(state, scope, result.releaseException()); return { }; } return promise; }
static ScriptPromise fulfillImageBitmap(ScriptState* scriptState, PassRefPtrWillBeRawPtr<ImageBitmap> imageBitmap) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); if (imageBitmap) { resolver->resolve(imageBitmap); } else { resolver->reject(ScriptValue(scriptState, v8::Null(scriptState->isolate()))); } return promise; }
ScriptPromise Cache::deleteImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options) { WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1)); batchOperations[0].operationType = WebServiceWorkerCache::OperationTypeDelete; request->populateWebServiceWorkerRequest(batchOperations[0].request); batchOperations[0].matchParams = toWebQueryParams(options); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); const ScriptPromise promise = resolver->promise(); m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations); return promise; }
ScriptPromise ServiceWorkerContainer::ready(ScriptState* scriptState) { if (m_controller.get()) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); resolver->resolve(m_controller.get()); return promise; } // FIXME: Elaborate the implementation when the "waiting" property // or replace() is implemented. return ScriptPromise(); }
ScriptPromise NavigatorServiceWorker::unregisterServiceWorker(ScriptExecutionContext* scriptExecutionContext, const String& pattern, ExceptionState& es) { ASSERT(RuntimeEnabledFeatures::serviceWorkerEnabled()); FrameLoaderClient* client = m_navigator->frame()->loader()->client(); WebKit::WebServiceWorkerRegistry* peer = client->serviceWorkerRegistry(); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptExecutionContext); if (peer) peer->unregisterServiceWorker(pattern, new CallbackPromiseAdapter(resolver)); else resolver->reject(PassRefPtr<ServiceWorker>(0)); return resolver->promise(); }
ScriptPromise StorageQuota::requestPersistentQuota(ExecutionContext* executionContext, unsigned long long newQuota) { ASSERT(executionContext); StorageQuotaClient* client = StorageQuotaClient::from(executionContext); if (!client) { RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(executionContext); resolver->reject(DOMError::create(NotSupportedError)); return resolver->promise(); } return client->requestPersistentQuota(executionContext, newQuota); }
ScriptPromise Permissions::query(ScriptState* scriptState, const ScriptValue& rawPermission) { WebPermissionClient* client = permissionClient(scriptState->executionContext()); if (!client) return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, "In its current state, the global scope can't query permissions.")); TrackExceptionState exceptionState; PermissionDescriptor permission = NativeValueTraits<PermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState); if (exceptionState.hadException()) return ScriptPromise::reject(scriptState, v8::Exception::TypeError(v8String(scriptState->isolate(), exceptionState.message()))); RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState); ScriptPromise promise = resolver->promise(); String name = permission.name(); WebPermissionType type; if (name == "geolocation") { type = WebPermissionTypeGeolocation; } else if (name == "notifications") { type = WebPermissionTypeNotifications; } else if (name == "push") { PushPermissionDescriptor pushPermission = NativeValueTraits<PushPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState); // Only "userVisible" push is supported for now. if (!pushPermission.userVisible()) { resolver->resolve(PermissionStatus::create(scriptState->executionContext(), WebPermissionStatusDenied, WebPermissionTypePush)); return promise; } type = WebPermissionTypePushNotifications; } else if (name == "midi") { MidiPermissionDescriptor midiPermission = NativeValueTraits<MidiPermissionDescriptor>::nativeValue(scriptState->isolate(), rawPermission.v8Value(), exceptionState); // Only sysex usage requires a permission for now. if (!midiPermission.sysex()) { resolver->resolve(PermissionStatus::create(scriptState->executionContext(), WebPermissionStatusGranted, WebPermissionTypeMidi)); return promise; } type = WebPermissionTypeMidiSysEx; } else { ASSERT_NOT_REACHED(); type = WebPermissionTypeGeolocation; } // If the current origin is a file scheme, it will unlikely return a // meaningful value because most APIs are broken on file scheme and no // permission prompt will be shown even if the returned permission will most // likely be "prompt". client->queryPermission(type, KURL(KURL(), scriptState->executionContext()->securityOrigin()->toString()), new PermissionQueryCallback(resolver, type)); return promise; }
static ScriptPromise startCryptoOperation(ScriptState* scriptState, const Dictionary& rawAlgorithm, Key* key, blink::WebCryptoOperation operationType, const ArrayPiece& signature, const ArrayPiece& dataBuffer) { RefPtr<CryptoResultImpl> result = CryptoResultImpl::create(scriptState); ScriptPromise promise = result->promise(); if (!canAccessWebCrypto(scriptState, result.get())) return promise; bool requiresKey = operationType != blink::WebCryptoOperationDigest; if (requiresKey && !ensureNotNull(key, "key", result.get())) return promise; if (operationType == blink::WebCryptoOperationVerify && !ensureNotNull(signature, "signature", result.get())) return promise; if (!ensureNotNull(dataBuffer, "dataBuffer", result.get())) return promise; blink::WebCryptoAlgorithm algorithm; if (!parseAlgorithm(rawAlgorithm, operationType, algorithm, result.get())) return promise; if (requiresKey && !key->canBeUsedForAlgorithm(algorithm, operationType, result.get())) return promise; const unsigned char* data = dataBuffer.bytes(); unsigned dataSize = dataBuffer.byteLength(); switch (operationType) { case blink::WebCryptoOperationEncrypt: blink::Platform::current()->crypto()->encrypt(algorithm, key->key(), data, dataSize, result->result()); break; case blink::WebCryptoOperationDecrypt: blink::Platform::current()->crypto()->decrypt(algorithm, key->key(), data, dataSize, result->result()); break; case blink::WebCryptoOperationSign: blink::Platform::current()->crypto()->sign(algorithm, key->key(), data, dataSize, result->result()); break; case blink::WebCryptoOperationVerify: blink::Platform::current()->crypto()->verifySignature(algorithm, key->key(), signature.bytes(), signature.byteLength(), data, dataSize, result->result()); break; case blink::WebCryptoOperationDigest: blink::Platform::current()->crypto()->digest(algorithm, data, dataSize, result->result()); break; default: ASSERT_NOT_REACHED(); return ScriptPromise(); } return promise; }
ScriptPromise SubtleCrypto::generateKey(const Dictionary& rawAlgorithm, bool extractable, const Vector<String>& rawKeyUsages, ExceptionState& es) { WebKit::WebCryptoKeyUsageMask keyUsages; if (!Key::parseUsageMask(rawKeyUsages, keyUsages, es)) return ScriptPromise(); WebKit::WebCryptoAlgorithm algorithm; if (!normalizeAlgorithm(rawAlgorithm, GenerateKey, algorithm, es)) return ScriptPromise(); RefPtr<CryptoResult> result = CryptoResult::create(); WebKit::Platform::current()->crypto()->generateKey(algorithm, extractable, keyUsages, result->result()); return result->promise(); }