String MediaControlsHost::externalDeviceType() const
{
DEPRECATED_DEFINE_STATIC_LOCAL(String, none, (ASCIILiteral("none")));
String type = none;
#if ENABLE(IOS_AIRPLAY)
DEPRECATED_DEFINE_STATIC_LOCAL(String, airplay, (ASCIILiteral("airplay")));
DEPRECATED_DEFINE_STATIC_LOCAL(String, tvout, (ASCIILiteral("tvout")));
MediaPlayer* player = m_mediaElement->player();
if (!player) {
LOG(Media, "MediaControlsHost::externalDeviceType - returning \"none\" because player is NULL");
return none;
}
switch (player->wirelessPlaybackTargetType()) {
case MediaPlayer::TargetTypeNone:
type = none;
break;
case MediaPlayer::TargetTypeAirPlay:
type = airplay;
break;
case MediaPlayer::TargetTypeTVOut:
type = tvout;
break;
}
#endif
LOG(Media, "MediaControlsHost::externalDeviceType - returning \"%s\"", type.utf8().data());
return type;
}
const String& LegacyRequest::readyState() const
{
ASSERT(m_readyState == IDBRequestReadyState::Pending || m_readyState == IDBRequestReadyState::Done);
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, pending, ("pending", AtomicString::ConstructFromLiteral));
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, done, ("done", AtomicString::ConstructFromLiteral));
if (m_readyState == IDBRequestReadyState::Pending)
return pending;
return done;
}
static const QualifiedName& nodeTypeToTagName(WebVTTNodeType nodeType)
{
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, cTag, (nullAtom, "c", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, vTag, (nullAtom, "v", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, langTag, (nullAtom, "lang", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, bTag, (nullAtom, "b", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, uTag, (nullAtom, "u", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, iTag, (nullAtom, "i", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, rubyTag, (nullAtom, "ruby", nullAtom));
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, rtTag, (nullAtom, "rt", nullAtom));
switch (nodeType) {
case WebVTTNodeTypeClass:
return cTag;
case WebVTTNodeTypeItalic:
return iTag;
case WebVTTNodeTypeLanguage:
return langTag;
case WebVTTNodeTypeBold:
return bTag;
case WebVTTNodeTypeUnderline:
return uTag;
case WebVTTNodeTypeRuby:
return rubyTag;
case WebVTTNodeTypeRubyText:
return rtTag;
case WebVTTNodeTypeVoice:
return vTag;
case WebVTTNodeTypeNone:
default:
ASSERT_NOT_REACHED();
return cTag; // Make the compiler happy.
}
}
void ScriptElement::notifyFinished(CachedResource* resource)
{
ASSERT(!m_willBeParserExecuted);
// CachedResource possibly invokes this notifyFinished() more than
// once because ScriptElement doesn't unsubscribe itself from
// CachedResource here and does it in execute() instead.
// We use m_cachedScript to check if this function is already called.
ASSERT_UNUSED(resource, resource == m_cachedScript);
if (!m_cachedScript)
return;
if (m_requestUsesAccessControl
&& !m_element.document().securityOrigin()->canRequest(m_cachedScript->response().url())
&& !m_cachedScript->passesAccessControlCheck(m_element.document().securityOrigin())) {
dispatchErrorEvent();
DEPRECATED_DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin script load denied by Cross-Origin Resource Sharing policy.")));
m_element.document().addConsoleMessage(MessageSource::JS, MessageLevel::Error, consoleMessage);
return;
}
if (m_willExecuteInOrder)
m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::IN_ORDER_EXECUTION);
else
m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::ASYNC_EXECUTION);
m_cachedScript = 0;
}
void TextPainter::paintText()
{
FloatPoint boxOrigin = m_boxRect.location();
if (!m_paintSelectedTextOnly) {
// For stroked painting, we have to change the text drawing mode. It's probably dangerous to leave that mutated as a side
// effect, so only when we know we're stroking, do a save/restore.
GraphicsContextStateSaver stateSaver(m_context, m_textPaintStyle.strokeWidth > 0);
updateGraphicsContext(m_context, m_textPaintStyle);
if (!m_paintSelectedTextSeparately || m_endPositionInTextRun <= m_startPositionInTextRun) {
// FIXME: Truncate right-to-left text correctly.
paintTextWithShadows(m_context, m_font, m_textRun, nullAtom, 0, 0, m_length, m_length, m_textOrigin, m_boxRect, m_textShadow, m_textPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
} else
paintTextWithShadows(m_context, m_font, m_textRun, nullAtom, 0, m_endPositionInTextRun, m_startPositionInTextRun, m_length, m_textOrigin, m_boxRect, m_textShadow, m_textPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
if (!m_emphasisMark.isEmpty()) {
updateGraphicsContext(m_context, m_textPaintStyle, UseEmphasisMarkColor);
static NeverDestroyed<TextRun> objectReplacementCharacterTextRun(&objectReplacementCharacter, 1);
TextRun& emphasisMarkTextRun = m_combinedText ? objectReplacementCharacterTextRun.get() : m_textRun;
FloatPoint emphasisMarkTextOrigin = m_combinedText ? FloatPoint(boxOrigin.x() + m_boxRect.width() / 2, boxOrigin.y() + m_font.fontMetrics().ascent()) : m_textOrigin;
if (m_combinedText)
m_context.concatCTM(rotation(m_boxRect, Clockwise));
if (!m_paintSelectedTextSeparately || m_endPositionInTextRun <= m_startPositionInTextRun) {
// FIXME: Truncate right-to-left text correctly.
paintTextWithShadows(m_context, m_combinedText ? m_combinedText->originalFont() : m_font, emphasisMarkTextRun, m_emphasisMark, m_emphasisMarkOffset, 0, m_length, m_length, emphasisMarkTextOrigin, m_boxRect, m_textShadow, m_textPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
} else
paintTextWithShadows(m_context, m_combinedText ? m_combinedText->originalFont() : m_font, emphasisMarkTextRun, m_emphasisMark, m_emphasisMarkOffset, m_endPositionInTextRun, m_startPositionInTextRun, m_length, emphasisMarkTextOrigin, m_boxRect, m_textShadow, m_textPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
if (m_combinedText)
m_context.concatCTM(rotation(m_boxRect, Counterclockwise));
}
}
if ((m_paintSelectedTextOnly || m_paintSelectedTextSeparately) && m_startPositionInTextRun < m_endPositionInTextRun) {
// paint only the text that is selected
GraphicsContextStateSaver stateSaver(m_context, m_selectionPaintStyle.strokeWidth > 0);
updateGraphicsContext(m_context, m_selectionPaintStyle);
paintTextWithShadows(m_context, m_font, m_textRun, nullAtom, 0, m_startPositionInTextRun, m_endPositionInTextRun, m_length, m_textOrigin, m_boxRect, m_selectionShadow, m_selectionPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
if (!m_emphasisMark.isEmpty()) {
updateGraphicsContext(m_context, m_selectionPaintStyle, UseEmphasisMarkColor);
DEPRECATED_DEFINE_STATIC_LOCAL(TextRun, objectReplacementCharacterTextRun, (&objectReplacementCharacter, 1));
TextRun& emphasisMarkTextRun = m_combinedText ? objectReplacementCharacterTextRun : m_textRun;
FloatPoint emphasisMarkTextOrigin = m_combinedText ? FloatPoint(boxOrigin.x() + m_boxRect.width() / 2, boxOrigin.y() + m_font.fontMetrics().ascent()) : m_textOrigin;
if (m_combinedText)
m_context.concatCTM(rotation(m_boxRect, Clockwise));
paintTextWithShadows(m_context, m_combinedText ? m_combinedText->originalFont() : m_font, emphasisMarkTextRun, m_emphasisMark, m_emphasisMarkOffset, m_startPositionInTextRun, m_endPositionInTextRun, m_length, emphasisMarkTextOrigin, m_boxRect, m_selectionShadow, m_selectionPaintStyle.strokeWidth > 0, m_textBoxIsHorizontal);
if (m_combinedText)
m_context.concatCTM(rotation(m_boxRect, Counterclockwise));
}
}
}
String PageDebuggerAgent::sourceMapURLForScript(const Script& script)
{
DEPRECATED_DEFINE_STATIC_LOCAL(String, sourceMapHTTPHeader, (ASCIILiteral("SourceMap")));
DEPRECATED_DEFINE_STATIC_LOCAL(String, sourceMapHTTPHeaderDeprecated, (ASCIILiteral("X-SourceMap")));
if (!script.url.isEmpty()) {
CachedResource* resource = m_pageAgent->cachedResource(m_pageAgent->mainFrame(), URL(ParsedURLString, script.url));
if (resource) {
String sourceMapHeader = resource->response().httpHeaderField(sourceMapHTTPHeader);
if (!sourceMapHeader.isEmpty())
return sourceMapHeader;
sourceMapHeader = resource->response().httpHeaderField(sourceMapHTTPHeaderDeprecated);
if (!sourceMapHeader.isEmpty())
return sourceMapHeader;
}
}
return InspectorDebuggerAgent::sourceMapURLForScript(script);
}
String NavigatorBase::platform() const
{
#if OS(LINUX)
if (!String(WEBCORE_NAVIGATOR_PLATFORM).isEmpty())
return WEBCORE_NAVIGATOR_PLATFORM;
struct utsname osname;
DEPRECATED_DEFINE_STATIC_LOCAL(String, platformName, (uname(&osname) >= 0 ? String(osname.sysname) + String(" ") + String(osname.machine) : emptyString()));
return platformName;
#else
return WEBCORE_NAVIGATOR_PLATFORM;
#endif
}
const String& SVGTransform::transformTypePrefixForParsing(SVGTransformType type)
{
switch (type) {
case SVG_TRANSFORM_UNKNOWN:
return emptyString();
case SVG_TRANSFORM_MATRIX: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, matrixString, (ASCIILiteral("matrix(")));
return matrixString;
}
case SVG_TRANSFORM_TRANSLATE: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, translateString, (ASCIILiteral("translate(")));
return translateString;
}
case SVG_TRANSFORM_SCALE: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, scaleString, (ASCIILiteral("scale(")));
return scaleString;
}
case SVG_TRANSFORM_ROTATE: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, rotateString, (ASCIILiteral("rotate(")));
return rotateString;
}
case SVG_TRANSFORM_SKEWX: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, skewXString, (ASCIILiteral("skewX(")));
return skewXString;
}
case SVG_TRANSFORM_SKEWY: {
DEPRECATED_DEFINE_STATIC_LOCAL(String, skewYString, (ASCIILiteral("skewY(")));
return skewYString;
}
}
ASSERT_NOT_REACHED();
return emptyString();
}
static String truncatedStringForLookupMenuItem(const String& original)
{
if (original.isEmpty())
return original;
// Truncate the string if it's too long. This is in consistency with AppKit.
unsigned maxNumberOfGraphemeClustersInLookupMenuItem = 24;
DEPRECATED_DEFINE_STATIC_LOCAL(String, ellipsis, (&horizontalEllipsis, 1));
String trimmed = original.stripWhiteSpace();
unsigned numberOfCharacters = numCharactersInGraphemeClusters(trimmed, maxNumberOfGraphemeClustersInLookupMenuItem);
return numberOfCharacters == trimmed.length() ? trimmed : trimmed.left(numberOfCharacters) + ellipsis;
}
void SVGMarkerElement::synchronizeOrientType(SVGElement* contextElement)
{
ASSERT(contextElement);
SVGMarkerElement& ownerType = downcast<SVGMarkerElement>(*contextElement);
if (!ownerType.m_orientType.shouldSynchronize)
return;
// If orient is not auto, the previous call to synchronizeOrientAngle already set the orientAttr to the right angle.
if (ownerType.m_orientType.value != SVGMarkerOrientAuto)
return;
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, autoString, ("auto", AtomicString::ConstructFromLiteral));
ownerType.m_orientType.synchronize(&ownerType, orientTypePropertyInfo()->attributeName, autoString);
}
void ImageLoader::notifyFinished(CachedResource* resource)
{
ASSERT(m_failedLoadURL.isEmpty());
ASSERT(resource == m_image.get());
m_imageComplete = true;
if (!hasPendingBeforeLoadEvent())
updateRenderer();
if (!m_hasPendingLoadEvent)
return;
if (element().fastHasAttribute(HTMLNames::crossoriginAttr)
&& !element().document().securityOrigin()->canRequest(image()->response().url())
&& !resource->passesAccessControlCheck(element().document().securityOrigin())) {
setImageWithoutConsideringPendingLoadEvent(0);
m_hasPendingErrorEvent = true;
errorEventSender().dispatchEventSoon(*this);
DEPRECATED_DEFINE_STATIC_LOCAL(String, consoleMessage, (ASCIILiteral("Cross-origin image load denied by Cross-Origin Resource Sharing policy.")));
element().document().addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage);
ASSERT(!m_hasPendingLoadEvent);
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
if (resource->wasCanceled()) {
m_hasPendingLoadEvent = false;
// Only consider updating the protection ref-count of the Element immediately before returning
// from this function as doing so might result in the destruction of this ImageLoader.
updatedHasPendingEvent();
return;
}
loadEventSender().dispatchEventSoon(*this);
}
const AtomicString& SVGFEConvolveMatrixElement::kernelUnitLengthXIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGKernelUnitLengthX", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGFEDiffuseLightingElement::kernelUnitLengthYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGKernelUnitLengthY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGFEMorphologyElement::radiusYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGRadiusY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGFEDropShadowElement::stdDeviationXIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationX", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const QualifiedName& nullQName()
{
DEPRECATED_DEFINE_STATIC_LOCAL(QualifiedName, nullName, (nullAtom, nullAtom, nullAtom));
return nullName;
}
void RenderCombineText::combineText()
{
if (!m_needsFontUpdate)
return;
m_isCombined = false;
m_needsFontUpdate = false;
// CSS3 spec says text-combine works only in vertical writing mode.
if (style().isHorizontalWritingMode())
return;
auto description = originalFont().fontDescription();
float emWidth = description.computedSize() * textCombineMargin;
bool shouldUpdateFont = false;
description.setOrientation(Horizontal); // We are going to draw combined text horizontally.
GlyphOverflow glyphOverflow;
glyphOverflow.computeBounds = true;
float combinedTextWidth = width(0, textLength(), originalFont(), 0, nullptr, &glyphOverflow);
m_isCombined = combinedTextWidth <= emWidth;
FontSelector* fontSelector = style().fontCascade().fontSelector();
if (m_isCombined)
shouldUpdateFont = m_combineFontStyle->setFontDescription(description); // Need to change font orientation to horizontal.
else {
// Need to try compressed glyphs.
static const FontWidthVariant widthVariants[] = { HalfWidth, ThirdWidth, QuarterWidth };
for (size_t i = 0 ; i < WTF_ARRAY_LENGTH(widthVariants) ; ++i) {
description.setWidthVariant(widthVariants[i]); // When modifying this, make sure to keep it in sync with FontPlatformData::isForTextCombine()!
FontCascade compressedFont(description, style().fontCascade().letterSpacing(), style().fontCascade().wordSpacing());
compressedFont.update(fontSelector);
float runWidth = RenderText::width(0, textLength(), compressedFont, 0, nullptr, &glyphOverflow);
if (runWidth <= emWidth) {
combinedTextWidth = runWidth;
m_isCombined = true;
// Replace my font with the new one.
shouldUpdateFont = m_combineFontStyle->setFontDescription(description);
break;
}
}
}
if (!m_isCombined)
shouldUpdateFont = m_combineFontStyle->setFontDescription(originalFont().fontDescription());
if (shouldUpdateFont)
m_combineFontStyle->fontCascade().update(fontSelector);
if (m_isCombined) {
DEPRECATED_DEFINE_STATIC_LOCAL(String, objectReplacementCharacterString, (&objectReplacementCharacter, 1));
RenderText::setRenderedText(objectReplacementCharacterString.impl());
m_combinedTextSize = FloatSize(combinedTextWidth, glyphOverflow.bottom + glyphOverflow.top);
}
}
const AtomicString& IDBTransaction::modeReadWriteLegacy()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, readwrite, ("1", AtomicString::ConstructFromLiteral));
return readwrite;
}
const AtomicString& SVGFETurbulenceElement::baseFrequencyYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGBaseFrequencyY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
NetworkStorageSession& NetworkStorageSession::defaultStorageSession()
{
DEPRECATED_DEFINE_STATIC_LOCAL(NetworkStorageSession, session, (0));
return session;
}
const AtomicString& MediaControls::shadowPseudoId() const
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, id, ("-webkit-media-controls"));
return id;
}
const AtomicString& SVGFEConvolveMatrixElement::orderYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGOrderY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGFilterElement::filterResYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGFilterResY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& IDBTransaction::modeReadOnlyLegacy()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, readonly, ("0", AtomicString::ConstructFromLiteral));
return readonly;
}
const AtomicString& SVGFEGaussianBlurElement::stdDeviationYIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGStdDeviationY", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGViewSpec::preserveAspectRatioIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGViewSpecPreserveAspectRatioAttribute", AtomicString::ConstructFromLiteral));
return s_identifier;
}
static const FixedSizeFontDataKey& emptyValue()
{
DEPRECATED_DEFINE_STATIC_LOCAL(FixedSizeFontDataKey, key, (nullAtom));
return key;
}
const AtomicString& SVGViewSpec::transformIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGViewSpecTransformAttribute", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& IDBTransaction::modeVersionChange()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, versionchange, ("versionchange", AtomicString::ConstructFromLiteral));
return versionchange;
}
const AtomicString& SVGMarkerElement::orientAngleIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGOrientAngle", AtomicString::ConstructFromLiteral));
return s_identifier;
}