void revoke() { ExecutionContext* executionContext = m_scriptState->getExecutionContext(); if (!executionContext) return; ScriptState::Scope scope(m_scriptState); v8::Local<v8::Value> value = m_promise.newLocal(m_scriptState->isolate()); v8::Local<v8::Value> reason = m_exception.newLocal(m_scriptState->isolate()); // Either collected or https://crbug.com/450330 if (value.IsEmpty() || !value->IsPromise()) return; EventTarget* target = executionContext->errorEventTarget(); if (RuntimeEnabledFeatures::promiseRejectionEventEnabled() && target && !executionContext->shouldSanitizeScriptError(m_resourceName, m_corsStatus)) { PromiseRejectionEventInit init; init.setPromise(ScriptPromise(m_scriptState, value)); init.setReason(ScriptValue(m_scriptState, reason)); RawPtr<PromiseRejectionEvent> event = PromiseRejectionEvent::create(m_scriptState, EventTypeNames::rejectionhandled, init); target->dispatchEvent(event); } if (m_shouldLogToConsole) { RawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, RevokedErrorMessageLevel, "Handler added to rejected promise"); consoleMessage->setRelatedMessageId(m_consoleMessageId); executionContext->addConsoleMessage(consoleMessage.release()); } }
void CSSVariableResolver::resolveAndApplyVariableReferences(StyleResolverState& state, CSSPropertyID id, const CSSVariableReferenceValue& value) { CSSVariableResolver resolver(state.style()->variables()); Vector<CSSParserToken> tokens; if (resolver.resolveTokenRange(value.variableDataValue()->tokens(), tokens)) { CSSParserContext context(HTMLStandardMode, 0); HeapVector<CSSProperty, 256> parsedProperties; // TODO: Non-shorthands should just call CSSPropertyParser::parseSingleValue if (CSSPropertyParser::parseValue(id, false, CSSParserTokenRange(tokens), context, parsedProperties, StyleRule::RuleType::Style)) { unsigned parsedPropertiesCount = parsedProperties.size(); for (unsigned i = 0; i < parsedPropertiesCount; ++i) StyleBuilder::applyProperty(parsedProperties[i].id(), state, parsedProperties[i].value()); return; } } RawPtr<CSSUnsetValue> unset = cssValuePool().createUnsetValue(); if (isShorthandProperty(id)) { StylePropertyShorthand shorthand = shorthandForProperty(id); for (unsigned i = 0; i < shorthand.length(); i++) StyleBuilder::applyProperty(shorthand.properties()[i], state, unset.get()); return; } StyleBuilder::applyProperty(id, state, unset.get()); }
void WorkerGlobalScope::addConsoleMessage(RawPtr<ConsoleMessage> prpConsoleMessage) { ASSERT(isContextThread()); RawPtr<ConsoleMessage> consoleMessage = prpConsoleMessage; thread()->workerReportingProxy().reportConsoleMessage(consoleMessage); addMessageToWorkerConsole(consoleMessage.release()); }
DispatchEventResult EventDispatcher::dispatchEvent(Node& node, RawPtr<EventDispatchMediator> mediator) { TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("blink.debug"), "EventDispatcher::dispatchEvent"); ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden()); EventDispatcher dispatcher(node, &mediator->event()); return mediator->dispatchEvent(dispatcher); }
RawPtr<HTMLElement> VTTElement::createEquivalentHTMLElement(Document& document) { RawPtr<HTMLElement> htmlElement = nullptr; switch (m_webVTTNodeType) { case VTTNodeTypeClass: case VTTNodeTypeLanguage: case VTTNodeTypeVoice: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::spanTag.localName(), document); htmlElement.get()->setAttribute(HTMLNames::titleAttr, getAttribute(voiceAttributeName())); htmlElement.get()->setAttribute(HTMLNames::langAttr, getAttribute(langAttributeName())); break; case VTTNodeTypeItalic: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::iTag.localName(), document); break; case VTTNodeTypeBold: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::bTag.localName(), document); break; case VTTNodeTypeUnderline: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::uTag.localName(), document); break; case VTTNodeTypeRuby: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::rubyTag.localName(), document); break; case VTTNodeTypeRubyText: htmlElement = HTMLElementFactory::createHTMLElement(HTMLNames::rtTag.localName(), document); break; default: ASSERT_NOT_REACHED(); } htmlElement.get()->setAttribute(HTMLNames::classAttr, getAttribute(HTMLNames::classAttr)); return htmlElement; }
void LuaStateAccess::setLuaInterpreter(lua_State* L, RawPtr<LuaInterpreter> luaInterpreter) { ExtraLuaStateData* extra = (ExtraLuaStateData*)((char*)(L) - sizeof(ExtraLuaStateData)); ASSERT(extra->luaInterpreter == NULL); extra->luaInterpreter = luaInterpreter.getRawPtr(); LuaStateAccess_HeapObjectRefManipulator::incWeakCounter(luaInterpreter.getRawPtr()); }
RawPtr<SVGPropertyBase> SVGAngleInterpolationType::appliedSVGValue(const InterpolableValue& interpolableValue, const NonInterpolableValue*) const { double doubleValue = toInterpolableNumber(interpolableValue).value(); RawPtr<SVGAngle> result = SVGAngle::create(); result->newValueSpecifiedUnits(SVGAngle::SVG_ANGLETYPE_DEG, doubleValue); return result.release(); }
TEST_F(AttrTest, InitialValueState) { RawPtr<Attr> attr = createAttribute(); EXPECT_EQ(emptyAtom, attr->value()); EXPECT_EQ(emptyString(), attr->toNode()->nodeValue()); EXPECT_EQ(String(), attr->textContent()); }
void HTMLElementStack::insertAbove(RawPtr<HTMLStackItem> item, ElementRecord* recordBelow) { ASSERT(item); ASSERT(recordBelow); ASSERT(m_top); ASSERT(!item->hasTagName(htmlTag)); ASSERT(!item->hasTagName(headTag)); ASSERT(!item->hasTagName(bodyTag)); ASSERT(m_rootNode); if (recordBelow == m_top) { push(item); return; } for (ElementRecord* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) { if (recordAbove->next() != recordBelow) continue; m_stackDepth++; recordAbove->setNext(new ElementRecord(item, recordAbove->releaseNext())); recordAbove->next()->element()->beginParsingChildren(); return; } ASSERT_NOT_REACHED(); }
RawPtr<DateTimeSecondFieldElement> DateTimeSecondFieldElement::create(Document& document, FieldOwner& fieldOwner, const Range& range, const Step& step) { DEFINE_STATIC_LOCAL(AtomicString, secondPseudoId, ("-webkit-datetime-edit-second-field")); RawPtr<DateTimeSecondFieldElement> field = new DateTimeSecondFieldElement(document, fieldOwner, range, step); field->initialize(secondPseudoId, queryString(WebLocalizedString::AXSecondFieldText)); return field.release(); }
RawPtr<Text> Text::splitText(unsigned offset, ExceptionState& exceptionState) { // IndexSizeError: Raised if the specified offset is negative or greater than // the number of 16-bit units in data. if (offset > length()) { exceptionState.throwDOMException(IndexSizeError, "The offset " + String::number(offset) + " is larger than the Text node's length."); return nullptr; } EventQueueScope scope; String oldStr = data(); RawPtr<Text> newText = cloneWithData(oldStr.substring(offset)); setDataWithoutUpdate(oldStr.substring(0, offset)); didModifyData(oldStr, CharacterData::UpdateFromNonParser); if (parentNode()) parentNode()->insertBefore(newText.get(), nextSibling(), exceptionState); if (exceptionState.hadException()) return nullptr; if (layoutObject()) layoutObject()->setTextWithOffset(dataImpl(), 0, oldStr.length()); if (parentNode()) document().didSplitTextNode(*this); return newText.release(); }
unsigned CSSGroupingRule::insertRule(const String& ruleString, unsigned index, ExceptionState& exceptionState) { ASSERT(m_childRuleCSSOMWrappers.size() == m_groupRule->childRules().size()); if (index > m_groupRule->childRules().size()) { exceptionState.throwDOMException(IndexSizeError, "the index " + String::number(index) + " must be less than or equal to the length of the rule list."); return 0; } CSSStyleSheet* styleSheet = parentStyleSheet(); CSSParserContext context(parserContext(), UseCounter::getFrom(styleSheet)); RawPtr<StyleRuleBase> newRule = CSSParser::parseRule(context, styleSheet ? styleSheet->contents() : nullptr, ruleString); if (!newRule) { exceptionState.throwDOMException(SyntaxError, "the rule '" + ruleString + "' is invalid and cannot be parsed."); return 0; } if (newRule->isNamespaceRule()) { exceptionState.throwDOMException(HierarchyRequestError, "'@namespace' rules cannot be inserted inside a group rule."); return 0; } if (newRule->isImportRule()) { // FIXME: an HierarchyRequestError should also be thrown for a nested @media rule. They are // currently not getting parsed, resulting in a SyntaxError to get raised above. exceptionState.throwDOMException(HierarchyRequestError, "'@import' rules cannot be inserted inside a group rule."); return 0; } CSSStyleSheet::RuleMutationScope mutationScope(this); m_groupRule->wrapperInsertRule(index, newRule); m_childRuleCSSOMWrappers.insert(index, Member<CSSRule>(nullptr)); return index; }
RawPtr<Text> GranularityStrategyTest::setupRotate(String str) { setInnerHTML( "<html>" "<head>" "<style>" "div {" "transform: translate(0px,600px) rotate(90deg);" "}" "</style>" "</head>" "<body>" "<div id='mytext'></div>" "</body>" "</html>"); RawPtr<Text> text = document().createTextNode(str); Element* div = document().getElementById("mytext"); div->appendChild(text); document().view()->updateAllLifecyclePhases(); parseText(text.get()); return text.release(); }
// Tests moving extent over to the other side of the vase and immediately // passing the word boundary and going into word granularity. TEST_F(GranularityStrategyTest, DirectionSwitchSideWordGranularityThenShrink) { dummyPageHolder().frame().settings()->setDefaultFontSize(12); String str = "ab cd efghijkl mnopqr iiin, abc"; RawPtr<Text> text = document().createTextNode(str); document().body()->appendChild(text); dummyPageHolder().frame().settings()->setSelectionStrategy(SelectionStrategy::Direction); parseText(text.get()); // "abcd efgh ijkl mno^pqr|> iiin, abc" (^ means base, | means extent, < means start, and > means end). selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21))); EXPECT_EQ_SELECTED_TEXT("pqr"); // Move to the middle of word #4 selecting it - this will set the offset to // be half the width of "iiin". selection().moveRangeSelectionExtent(m_wordMiddles[4]); EXPECT_EQ_SELECTED_TEXT("pqr iiin"); // Move to the middle of word #2 - extent will switch over to the other // side of the base, and we should enter word granularity since we pass // the word boundary. The offset should become negative since the width // of "efghjkkl" is greater than that of "iiin". int offset = m_letterPos[26].x() - m_wordMiddles[4].x(); IntPoint p = IntPoint(m_wordMiddles[2].x() - offset - 1, m_wordMiddles[2].y()); selection().moveRangeSelectionExtent(p); EXPECT_EQ_SELECTED_TEXT("efghijkl mno"); p.move(m_letterPos[7].x() - m_letterPos[6].x(), 0); selection().moveRangeSelectionExtent(p); EXPECT_EQ_SELECTED_TEXT("fghijkl mno"); }
RawPtr<DateTimeYearFieldElement> DateTimeYearFieldElement::create(Document& document, FieldOwner& fieldOwner, const DateTimeYearFieldElement::Parameters& parameters) { DEFINE_STATIC_LOCAL(AtomicString, yearPseudoId, ("-webkit-datetime-edit-year-field")); RawPtr<DateTimeYearFieldElement> field = new DateTimeYearFieldElement(document, fieldOwner, parameters); field->initialize(yearPseudoId, queryString(WebLocalizedString::AXYearFieldText)); return field.release(); }
RawPtr<DateTimeDayFieldElement> DateTimeDayFieldElement::create(Document& document, FieldOwner& fieldOwner, const String& placeholder, const Range& range) { DEFINE_STATIC_LOCAL(AtomicString, dayPseudoId, ("-webkit-datetime-edit-day-field")); RawPtr<DateTimeDayFieldElement> field = new DateTimeDayFieldElement(document, fieldOwner, placeholder.isEmpty() ? "--" : placeholder, range); field->initialize(dayPseudoId, queryString(WebLocalizedString::AXDayOfMonthFieldText)); return field.release(); }
RawPtr<DateTimeWeekFieldElement> DateTimeWeekFieldElement::create(Document& document, FieldOwner& fieldOwner, const Range& range) { DEFINE_STATIC_LOCAL(AtomicString, weekPseudoId, ("-webkit-datetime-edit-week-field")); RawPtr<DateTimeWeekFieldElement> field = new DateTimeWeekFieldElement(document, fieldOwner, range); field->initialize(weekPseudoId, queryString(WebLocalizedString::AXWeekOfYearFieldText)); return field.release(); }
RawPtr<DateTimeSymbolicMonthFieldElement> DateTimeSymbolicMonthFieldElement::create(Document& document, FieldOwner& fieldOwner, const Vector<String>& labels, int minimum, int maximum) { DEFINE_STATIC_LOCAL(AtomicString, monthPseudoId, ("-webkit-datetime-edit-month-field")); RawPtr<DateTimeSymbolicMonthFieldElement> field = new DateTimeSymbolicMonthFieldElement(document, fieldOwner, labels, minimum, maximum); field->initialize(monthPseudoId, queryString(WebLocalizedString::AXMonthFieldText)); return field.release(); }
RawPtr<DateTimeAMPMFieldElement> DateTimeAMPMFieldElement::create(Document& document, FieldOwner& fieldOwner, const Vector<String>& ampmLabels) { DEFINE_STATIC_LOCAL(AtomicString, ampmPseudoId, ("-webkit-datetime-edit-ampm-field")); RawPtr<DateTimeAMPMFieldElement> field = new DateTimeAMPMFieldElement(document, fieldOwner, ampmLabels); field->initialize(ampmPseudoId, queryString(WebLocalizedString::AXAMPMFieldText)); return field.release(); }
TEST_F(AttrTest, LengthOfContents) { RawPtr<Attr> attr = createAttribute(); EXPECT_EQ(0u, attr->lengthOfContents()); attr->setValue(value()); EXPECT_EQ(0u, attr->lengthOfContents()); }
void HTMLElementStack::pushHTMLBodyElement(RawPtr<HTMLStackItem> item) { ASSERT(item->hasTagName(HTMLNames::bodyTag)); ASSERT(!m_bodyElement); m_bodyElement = item->element(); pushCommon(item); }
void ConsoleBase::timeEnd(ScriptState* scriptState, const String& title) { TRACE_EVENT_COPY_ASYNC_END0("blink.console", title.utf8().data(), this); // Follow Firebug's behavior of requiring a title that is not null or // undefined for timing functions if (title.isNull()) return; HashMap<String, double>::iterator it = m_times.find(title); if (it == m_times.end()) return; double startTime = it->value; m_times.remove(it); double elapsed = monotonicallyIncreasingTime() - startTime; String message = title + String::format(": %.3fms", elapsed * 1000); RawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(ConsoleAPIMessageSource, DebugMessageLevel, message); consoleMessage->setType(TimeEndMessageType); consoleMessage->setScriptState(scriptState); consoleMessage->setCallStack(ScriptCallStack::capture(1)); reportMessageToConsole(consoleMessage.release()); }
void WorkerGlobalScope::dispose() { ASSERT(thread()->isCurrentThread()); stopActiveDOMObjects(); // Event listeners would keep DOMWrapperWorld objects alive for too long. Also, they have references to JS objects, // which become dangling once Heap is destroyed. for (auto it = m_eventListeners.begin(); it != m_eventListeners.end(); ) { RawPtr<V8AbstractEventListener> listener = *it; // clearListenerObject() will unregister the listener from // m_eventListeners, and invalidate the iterator, so we have to advance // it first. ++it; listener->clearListenerObject(); } removeAllEventListeners(); clearScript(); clearInspector(); m_eventQueue->close(); // We do not clear the thread field of the // WorkerGlobalScope. Other objects keep the worker global scope // alive because they need its thread field to check that work is // being carried out on the right thread. We therefore cannot clear // the thread field before all references to the worker global // scope are gone. }
RawPtr<HTMLVideoElement> HTMLVideoElement::create(Document& document) { RawPtr<HTMLVideoElement> video = new HTMLVideoElement(document); video->ensureUserAgentShadowRoot(); video->suspendIfNeeded(); return video.release(); }
LuaAccess::Result LuaAccess::executeScript(const char* scriptBegin, long scriptLength) const { ASSERT(isCorrect()); RawPtr<LuaInterpreter> luaInterpreter = getLuaInterpreter(); internLoadBuffer(scriptBegin, scriptLength); String oldPrintBuffer = LuaInterpreter::PrintBufferAccess::getPrintBuffer(luaInterpreter); LuaInterpreter::PrintBufferAccess::setPrintBuffer(luaInterpreter, String()); int oldTop = lua_gettop(L); int error = lua_pcall(L, 0, LUA_MULTRET, luaInterpreter->getErrorHandlerStackIndex()); String printBuffer = LuaInterpreter::PrintBufferAccess::getPrintBuffer(luaInterpreter); LuaInterpreter::PrintBufferAccess::setPrintBuffer(luaInterpreter, oldPrintBuffer); if (error) { LuaVar errorObject(*this, lua_gettop(L)); throw LuaException(errorObject); } Result rslt; rslt.output = printBuffer; for (int i = oldTop, n = lua_gettop(L); i <= n; ++i) { rslt.objects.appendObjectWithStackIndex(*this, i); } return rslt; }
void HTMLElementStack::push(RawPtr<HTMLStackItem> item) { ASSERT(!item->hasTagName(htmlTag)); ASSERT(!item->hasTagName(headTag)); ASSERT(!item->hasTagName(bodyTag)); ASSERT(m_rootNode); pushCommon(item); }
WebRemoteFrame* WebRemoteFrameImpl::createRemoteChild(WebTreeScopeType scope, const WebString& name, const WebString& uniqueName, WebSandboxFlags sandboxFlags, WebRemoteFrameClient* client, WebFrame* opener) { WebRemoteFrameImpl* child = WebRemoteFrameImpl::create(scope, client, opener); appendChild(child); RawPtr<RemoteFrameOwner> owner = RemoteFrameOwner::create(static_cast<SandboxFlags>(sandboxFlags), WebFrameOwnerProperties()); child->initializeCoreFrame(frame()->host(), owner.get(), name, uniqueName); return child; }
TEST(HTMLLinkElementSizesAttributeTest, setHTMLForProperty_updatesForAttribute) { RawPtr<Document> document = Document::create(); RawPtr<HTMLOutputElement> element = HTMLOutputElement::create(*document, /* form: */ nullptr); EXPECT_EQ(nullAtom, element->getAttribute(HTMLNames::forAttr)); element->htmlFor()->setValue(" strawberry "); EXPECT_EQ(" strawberry ", element->getAttribute(HTMLNames::forAttr)); }
static RawPtr<EditingStyle> styleFromMatchedRulesAndInlineDecl(const HTMLElement* element) { RawPtr<EditingStyle> style = EditingStyle::create(element->inlineStyle()); // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to untangle // the non-const-ness of styleFromMatchedRulesForElement. style->mergeStyleFromRules(const_cast<HTMLElement*>(element)); return style.release(); }
TEST_F(AttrTest, SetTextContent) { RawPtr<Attr> attr = createAttribute(); // Node::setTextContent() does nothing for Attr. attr->setTextContent(value()); EXPECT_EQ(emptyAtom, attr->value()); EXPECT_EQ(emptyString(), attr->toNode()->nodeValue()); EXPECT_EQ(String(), attr->textContent()); }