Ref<Inspector::Protocol::Runtime::StructureDescription> StructureShape::inspectorRepresentation()
{
auto base = Inspector::Protocol::Runtime::StructureDescription::create().release();
Ref<Inspector::Protocol::Runtime::StructureDescription> currentObject = base.copyRef();
RefPtr<StructureShape> currentShape(this);
while (currentShape) {
auto fields = Inspector::Protocol::Array<String>::create();
auto optionalFields = Inspector::Protocol::Array<String>::create();
for (auto field : currentShape->m_fields)
fields->addItem(field.get());
for (auto field : currentShape->m_optionalFields)
optionalFields->addItem(field.get());
currentObject->setFields(&fields.get());
currentObject->setOptionalFields(&optionalFields.get());
currentObject->setConstructorName(currentShape->m_constructorName);
currentObject->setIsImprecise(currentShape->m_isInDictionaryMode);
if (currentShape->m_proto) {
auto nextObject = Inspector::Protocol::Runtime::StructureDescription::create().release();
currentObject->setPrototypeStructure(&nextObject.get());
currentObject = WTF::move(nextObject);
}
currentShape = currentShape->m_proto;
}
return WTF::move(base);
}
void ScriptRunner::queueScriptForExecution(ScriptElement& scriptElement, LoadableScript& loadableScript, ExecutionType executionType)
{
ASSERT(scriptElement.element().inDocument());
m_document.incrementLoadEventDelayCount();
auto pendingScript = PendingScript::create(scriptElement, loadableScript);
switch (executionType) {
case ASYNC_EXECUTION:
m_pendingAsyncScripts.add(pendingScript.copyRef());
break;
case IN_ORDER_EXECUTION:
m_scriptsToExecuteInOrder.append(pendingScript.copyRef());
break;
}
pendingScript->setClient(*this);
}
void WebBatteryManager::updateBatteryStatus(const WebBatteryStatus::Data& data)
{
auto status = BatteryStatus::create(data.isCharging, data.chargingTime, data.dischargingTime, data.level);
for (auto* page : m_pageSet) {
if (page->corePage())
BatteryController::from(page->corePage())->updateBatteryStatus(status.copyRef());
}
}
int Geolocation::watchPosition(Ref<PositionCallback>&& successCallback, RefPtr<PositionErrorCallback>&& errorCallback, PositionOptions&& options)
{
if (!frame())
return 0;
auto notifier = GeoNotifier::create(*this, WTFMove(successCallback), WTFMove(errorCallback), WTFMove(options));
startRequest(notifier.ptr());
int watchID;
// Keep asking for the next id until we're given one that we don't already have.
do {
watchID = m_scriptExecutionContext->circularSequentialID();
} while (!m_watchers.add(watchID, notifier.copyRef()));
return watchID;
}
void InbandDataTextTrack::addDataCue(InbandTextTrackPrivate*, const MediaTime& start, const MediaTime& end, PassRefPtr<SerializedPlatformRepresentation> prpPlatformValue, const String& type)
{
RefPtr<SerializedPlatformRepresentation> platformValue = prpPlatformValue;
if (m_incompleteCueMap.find(platformValue.get()) != m_incompleteCueMap.end())
return;
auto cue = DataCue::create(*scriptExecutionContext(), start, end, platformValue.copyRef(), type);
if (hasCue(cue.ptr(), TextTrackCue::IgnoreDuration)) {
LOG(Media, "InbandDataTextTrack::addDataCue ignoring already added cue: start=%s, end=%s\n", toString(cue->startTime()).utf8().data(), toString(cue->endTime()).utf8().data());
return;
}
if (end.isPositiveInfinite() && mediaElement()) {
cue->setEndTime(mediaElement()->durationMediaTime());
m_incompleteCueMap.add(WTFMove(platformValue), cue.copyRef());
}
addCue(WTFMove(cue), ASSERT_NO_EXCEPTION);
}
JSC::JSInternalPromise* ScriptModuleLoader::fetch(JSC::JSGlobalObject* jsGlobalObject, JSC::ExecState* exec, JSC::JSModuleLoader*, JSC::JSValue moduleKeyValue, JSC::JSValue initiator)
{
auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(jsGlobalObject);
auto& jsPromise = *JSC::JSInternalPromiseDeferred::create(exec, &globalObject);
auto deferred = DeferredPromise::create(globalObject, jsPromise);
if (moduleKeyValue.isSymbol()) {
deferred->reject(TypeError, ASCIILiteral("Symbol module key should be already fulfilled with the inlined resource."));
return jsPromise.promise();
}
if (!moduleKeyValue.isString()) {
deferred->reject(TypeError, ASCIILiteral("Module key is not Symbol or String."));
return jsPromise.promise();
}
// https://html.spec.whatwg.org/multipage/webappapis.html#fetch-a-single-module-script
URL completedURL(URL(), asString(moduleKeyValue)->value(exec));
if (!completedURL.isValid()) {
deferred->reject(TypeError, ASCIILiteral("Module key is a valid URL."));
return jsPromise.promise();
}
ASSERT_WITH_MESSAGE(JSC::jsDynamicCast<JSElement*>(initiator), "Initiator should be an JSElement");
auto* scriptElement = toScriptElementIfPossible(&JSC::jsCast<JSElement*>(initiator)->wrapped());
ASSERT_WITH_MESSAGE(scriptElement, "Initiator should be ScriptElement.");
if (auto* frame = m_document.frame()) {
auto loader = CachedModuleScriptLoader::create(*this, deferred.get());
m_loaders.add(loader.copyRef());
if (!loader->load(*scriptElement, completedURL)) {
loader->clearClient();
m_loaders.remove(WTFMove(loader));
deferred->reject(frame->script().moduleLoaderAlreadyReportedErrorSymbol());
return jsPromise.promise();
}
}
return jsPromise.promise();
}
void FontFaceSet::load(JSC::ExecState& execState, const String& font, const String& text, DeferredWrapper&& promise, ExceptionCode& ec)
{
auto matchingFaces = m_backing->matchingFaces(font, text, ec);
if (ec)
return;
if (matchingFaces.isEmpty()) {
promise.resolve(Vector<RefPtr<FontFace>>());
return;
}
for (auto& face : matchingFaces)
face.get().load();
auto pendingPromise = PendingPromise::create(WTFMove(promise));
bool waiting = false;
for (auto& face : matchingFaces) {
if (face.get().status() == CSSFontFace::Status::Failure) {
pendingPromise->promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)));
return;
}
}
for (auto& face : matchingFaces) {
pendingPromise->faces.append(face.get().wrapper(execState));
if (face.get().status() == CSSFontFace::Status::Success)
continue;
waiting = true;
auto& vector = m_pendingPromises.add(RefPtr<CSSFontFace>(&face.get()), Vector<Ref<PendingPromise>>()).iterator->value;
vector.append(pendingPromise.copyRef());
}
if (!waiting)
pendingPromise->promise.resolve(pendingPromise->faces);
}
void FontFaceSet::load(const String& font, const String& text, LoadPromise&& promise)
{
auto matchingFacesResult = m_backing->matchingFaces(font, text);
if (matchingFacesResult.hasException()) {
promise.reject(matchingFacesResult.releaseException());
return;
}
auto matchingFaces = matchingFacesResult.releaseReturnValue();
if (matchingFaces.isEmpty()) {
promise.resolve(Vector<RefPtr<FontFace>>());
return;
}
for (auto& face : matchingFaces)
face.get().load();
for (auto& face : matchingFaces) {
if (face.get().status() == CSSFontFace::Status::Failure) {
promise.reject(NETWORK_ERR);
return;
}
}
auto pendingPromise = PendingPromise::create(WTFMove(promise));
bool waiting = false;
for (auto& face : matchingFaces) {
pendingPromise->faces.append(face.get().wrapper());
if (face.get().status() == CSSFontFace::Status::Success)
continue;
waiting = true;
ASSERT(face.get().existingWrapper());
m_pendingPromises.add(face.get().existingWrapper(), Vector<Ref<PendingPromise>>()).iterator->value.append(pendingPromise.copyRef());
}
if (!waiting)
pendingPromise->promise.resolve(pendingPromise->faces);
}
