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