#include "config.h"
#include "MediaList.h"
#include "CSSImportRule.h"
#include "CSSParser.h"
#include "CSSStyleSheet.h"
#include "DOMWindow.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "HTMLParserIdioms.h"
#include "MediaFeatureNames.h"
#include "MediaQuery.h"
#include "ScriptableDocumentParser.h"
#include <wtf/NeverDestroyed.h>
#include <wtf/text/StringBuilder.h>
namespace WebCore {
MediaQuerySet::MediaQuerySet()
: m_fallbackToDescriptor(false)
, m_lastLine(0)
{
}
MediaQuerySet::MediaQuerySet(const String& mediaString, bool fallbackToDescriptor)
: m_fallbackToDescriptor(fallbackToDescriptor)
, m_lastLine(0)
{
bool success = parse(mediaString);
if (!success)
parse("invalid");
}
MediaQuerySet::MediaQuerySet(const MediaQuerySet& o)
: RefCounted()
, m_fallbackToDescriptor(o.m_fallbackToDescriptor)
, m_lastLine(o.m_lastLine)
, m_queries(o.m_queries)
{
}
MediaQuerySet::~MediaQuerySet()
{
}
static String parseMediaDescriptor(const String& string)
{
unsigned length = string.length();
unsigned i;
for (i = 0; i < length; ++i) {
auto character = string[i];
if (!(isASCIIAlphanumeric(character) || character == '-'))
break;
}
return string.left(i);
}
Optional<MediaQuery> MediaQuerySet::internalParse(CSSParser& parser, const String& queryString)
{
if (auto query = parser.parseMediaQuery(queryString))
return WTFMove(*query);
if (!m_fallbackToDescriptor)
return Nullopt;
return MediaQuery { MediaQuery::None, parseMediaDescriptor(queryString), Vector<MediaQueryExpression> { } };
}
Optional<MediaQuery> MediaQuerySet::internalParse(const String& queryString)
{
CSSParser parser(CSSStrictMode);
return internalParse(parser, queryString);
}
bool MediaQuerySet::parse(const String& mediaString)
{
CSSParser parser(CSSStrictMode);
Vector<MediaQuery> result;
Vector<String> list;
mediaString.split(',', list);
for (auto& listString : list) {
String medium = stripLeadingAndTrailingHTMLSpaces(listString);
if (medium.isEmpty()) {
if (m_fallbackToDescriptor)
continue;
} else if (auto query = internalParse(parser, medium)) {
result.append(WTFMove(query.value()));
continue;
}
return false;
}
if (!m_fallbackToDescriptor && list.isEmpty()) {
String strippedMediaString = stripLeadingAndTrailingHTMLSpaces(mediaString);
if (!strippedMediaString.isEmpty())
return false;
}
m_queries = WTFMove(result);
return true;
}
bool MediaQuerySet::add(const String& queryString)
{
auto parsedQuery = internalParse(queryString);
if (!parsedQuery)
return false;
m_queries.append(WTFMove(parsedQuery.value()));
return true;
}
bool MediaQuerySet::remove(const String& queryString)
{
auto parsedQuery = internalParse(queryString);
if (!parsedQuery)
return false;
return m_queries.removeFirstMatching([&parsedQuery](auto& query) {
return query == parsedQuery.value();
});
}
void MediaQuerySet::addMediaQuery(MediaQuery&& mediaQuery)
{
m_queries.append(WTFMove(mediaQuery));
}
String MediaQuerySet::mediaText() const
{
StringBuilder text;
bool needComma = false;
for (auto& query : m_queries) {
if (needComma)
text.appendLiteral(", ");
text.append(query.cssText());
needComma = true;
}
return text.toString();
}
MediaList::MediaList(MediaQuerySet* mediaQueries, CSSStyleSheet* parentSheet)
: m_mediaQueries(mediaQueries)
, m_parentStyleSheet(parentSheet)
{
}
MediaList::MediaList(MediaQuerySet* mediaQueries, CSSRule* parentRule)
: m_mediaQueries(mediaQueries)
, m_parentRule(parentRule)
{
}
MediaList::~MediaList()
{
}
void MediaList::setMediaText(const String& value, ExceptionCode& ec)
{
CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
if (!m_mediaQueries->parse(value)) {
ec = SYNTAX_ERR;
return;
}
if (m_parentStyleSheet)
m_parentStyleSheet->didMutate();
}
String MediaList::item(unsigned index) const
{
auto& queries = m_mediaQueries->queryVector();
if (index < queries.size())
return queries[index].cssText();
return String();
}
void MediaList::deleteMedium(const String& medium, ExceptionCode& ec)
{
CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
bool success = m_mediaQueries->remove(medium);
if (!success) {
ec = NOT_FOUND_ERR;
return;
}
if (m_parentStyleSheet)
m_parentStyleSheet->didMutate();
}
void MediaList::appendMedium(const String& medium, ExceptionCode& ec)
{
CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
bool success = m_mediaQueries->add(medium);
if (!success) {
ec = INVALID_CHARACTER_ERR;
return;
}
if (m_parentStyleSheet)
m_parentStyleSheet->didMutate();
}
void MediaList::reattach(MediaQuerySet* mediaQueries)
{
ASSERT(mediaQueries);
m_mediaQueries = mediaQueries;
}
#if ENABLE(RESOLUTION_MEDIA_QUERY)
static void addResolutionWarningMessageToConsole(Document& document, const String& serializedExpression, const CSSPrimitiveValue& value)
{
static NeverDestroyed<String> mediaQueryMessage(ASCIILiteral("Consider using 'dppx' units instead of '%replacementUnits%', as in CSS '%replacementUnits%' means dots-per-CSS-%lengthUnit%, not dots-per-physical-%lengthUnit%, so does not correspond to the actual '%replacementUnits%' of a screen. In media query expression: "));
static NeverDestroyed<String> mediaValueDPI(ASCIILiteral("dpi"));
static NeverDestroyed<String> mediaValueDPCM(ASCIILiteral("dpcm"));
static NeverDestroyed<String> lengthUnitInch(ASCIILiteral("inch"));
static NeverDestroyed<String> lengthUnitCentimeter(ASCIILiteral("centimeter"));
String message;
if (value.isDotsPerInch())
message = mediaQueryMessage.get().replace("%replacementUnits%", mediaValueDPI).replace("%lengthUnit%", lengthUnitInch);
else if (value.isDotsPerCentimeter())
message = mediaQueryMessage.get().replace("%replacementUnits%", mediaValueDPCM).replace("%lengthUnit%", lengthUnitCentimeter);
else
ASSERT_NOT_REACHED();
message.append(serializedExpression);
document.addConsoleMessage(MessageSource::CSS, MessageLevel::Debug, message);
}
void reportMediaQueryWarningIfNeeded(Document* document, const MediaQuerySet* mediaQuerySet)
{
if (!mediaQuerySet || !document)
return;
for (auto& query : mediaQuerySet->queryVector()) {
if (!query.ignored() && !equalLettersIgnoringASCIICase(query.mediaType(), "print")) {
auto& expressions = query.expressions();
for (auto& expression : expressions) {
if (expression.mediaFeature() == MediaFeatureNames::resolution || expression.mediaFeature() == MediaFeatureNames::maxResolution || expression.mediaFeature() == MediaFeatureNames::minResolution) {
auto* value = expression.value();
if (is<CSSPrimitiveValue>(value)) {
auto& primitiveValue = downcast<CSSPrimitiveValue>(*value);
if (primitiveValue.isDotsPerInch() || primitiveValue.isDotsPerCentimeter())
addResolutionWarningMessageToConsole(*document, mediaQuerySet->mediaText(), primitiveValue);
}
}
}
}
}
}
#endif
}