c5577b7f2a934c8e2642a41f26bcb8db855a7b47
[WebKit-https.git] / Source / WebCore / css / MediaList.cpp
1 /*
2  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
3  * Copyright (C) 2004, 2006, 2010, 2012 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  */
20 #include "config.h"
21 #include "MediaList.h"
22
23 #include "CSSImportRule.h"
24 #include "CSSParser.h"
25 #include "CSSStyleSheet.h"
26 #include "DOMWindow.h"
27 #include "Document.h"
28 #include "ExceptionCode.h"
29 #include "MediaFeatureNames.h"
30 #include "MediaQuery.h"
31 #include "MediaQueryExp.h"
32 #include "ScriptableDocumentParser.h"
33 #include <wtf/text/StringBuilder.h>
34
35 namespace WebCore {
36
37 /* MediaList is used to store 3 types of media related entities which mean the same:
38  * Media Queries, Media Types and Media Descriptors.
39  * Currently MediaList always tries to parse media queries and if parsing fails,
40  * tries to fallback to Media Descriptors if m_fallbackToDescriptor flag is set.
41  * Slight problem with syntax error handling:
42  * CSS 2.1 Spec (http://www.w3.org/TR/CSS21/media.html)
43  * specifies that failing media type parsing is a syntax error
44  * CSS 3 Media Queries Spec (http://www.w3.org/TR/css3-mediaqueries/)
45  * specifies that failing media query is a syntax error
46  * HTML 4.01 spec (http://www.w3.org/TR/REC-html40/present/styles.html#adef-media)
47  * specifies that Media Descriptors should be parsed with forward-compatible syntax
48  * DOM Level 2 Style Sheet spec (http://www.w3.org/TR/DOM-Level-2-Style/)
49  * talks about MediaList.mediaText and refers
50  *   -  to Media Descriptors of HTML 4.0 in context of StyleSheet
51  *   -  to Media Types of CSS 2.0 in context of CSSMediaRule and CSSImportRule
52  *
53  * These facts create situation where same (illegal) media specification may result in
54  * different parses depending on whether it is media attr of style element or part of
55  * css @media rule.
56  * <style media="screen and resolution > 40dpi"> ..</style> will be enabled on screen devices where as
57  * @media screen and resolution > 40dpi {..} will not.
58  * This gets more counter-intuitive in JavaScript:
59  * document.styleSheets[0].media.mediaText = "screen and resolution > 40dpi" will be ok and
60  * enabled, while
61  * document.styleSheets[0].cssRules[0].media.mediaText = "screen and resolution > 40dpi" will
62  * throw SYNTAX_ERR exception.
63  */
64     
65 MediaQuerySet::MediaQuerySet()
66     : m_fallbackToDescriptor(false)
67     , m_lastLine(0)
68 {
69 }
70
71 MediaQuerySet::MediaQuerySet(const String& mediaString, bool fallbackToDescriptor)
72     : m_fallbackToDescriptor(fallbackToDescriptor)
73     , m_lastLine(0)
74 {
75     bool success = parse(mediaString);
76     // FIXME: parsing can fail. The problem with failing constructor is that
77     // we would need additional flag saying MediaList is not valid
78     // Parse can fail only when fallbackToDescriptor == false, i.e when HTML4 media descriptor
79     // forward-compatible syntax is not in use.
80     // DOMImplementationCSS seems to mandate that media descriptors are used
81     // for both html and svg, even though svg:style doesn't use media descriptors
82     // Currently the only places where parsing can fail are
83     // creating <svg:style>, creating css media / import rules from js
84     
85     // FIXME: This doesn't make much sense.
86     if (!success)
87         parse("invalid");
88 }
89
90 MediaQuerySet::MediaQuerySet(const MediaQuerySet& o)
91     : RefCounted<MediaQuerySet>()
92     , m_fallbackToDescriptor(o.m_fallbackToDescriptor)
93     , m_lastLine(o.m_lastLine)
94     , m_queries(o.m_queries.size())
95 {
96     for (unsigned i = 0; i < m_queries.size(); ++i)
97         m_queries[i] = o.m_queries[i]->copy();
98 }
99
100 MediaQuerySet::~MediaQuerySet()
101 {
102 }
103
104 static String parseMediaDescriptor(const String& string)
105 {
106     // http://www.w3.org/TR/REC-html40/types.html#type-media-descriptors
107     // "Each entry is truncated just before the first character that isn't a
108     // US ASCII letter [a-zA-Z] (ISO 10646 hex 41-5a, 61-7a), digit [0-9] (hex 30-39),
109     // or hyphen (hex 2d)."
110     unsigned length = string.length();
111     unsigned i = 0;
112     for (; i < length; ++i) {
113         unsigned short c = string[i];
114         if (! ((c >= 'a' && c <= 'z')
115                || (c >= 'A' && c <= 'Z')
116                || (c >= '1' && c <= '9')
117                || (c == '-')))
118             break;
119     }
120     return string.left(i);
121 }
122
123 bool MediaQuerySet::parse(const String& mediaString)
124 {
125     CSSParser parser(CSSStrictMode);
126     
127     Vector<std::unique_ptr<MediaQuery>> result;
128     Vector<String> list;
129     mediaString.split(',', list);
130     for (unsigned i = 0; i < list.size(); ++i) {
131         String medium = list[i].stripWhiteSpace();
132         if (medium.isEmpty()) {
133             if (!m_fallbackToDescriptor)
134                 return false;
135             continue;
136         }
137         std::unique_ptr<MediaQuery> mediaQuery = parser.parseMediaQuery(medium);
138         if (!mediaQuery) {
139             if (!m_fallbackToDescriptor)
140                 return false;
141             String mediaDescriptor = parseMediaDescriptor(medium);
142             if (mediaDescriptor.isNull())
143                 continue;
144             mediaQuery = std::make_unique<MediaQuery>(MediaQuery::None, mediaDescriptor, nullptr);
145         }
146         result.append(WTFMove(mediaQuery));
147     }
148     // ",,,," falls straight through, but is not valid unless fallback
149     if (!m_fallbackToDescriptor && list.isEmpty()) {
150         String strippedMediaString = mediaString.stripWhiteSpace();
151         if (!strippedMediaString.isEmpty())
152             return false;
153     }
154     m_queries = WTFMove(result);
155     return true;
156 }
157
158 bool MediaQuerySet::add(const String& queryString)
159 {
160     CSSParser parser(CSSStrictMode);
161
162     std::unique_ptr<MediaQuery> parsedQuery = parser.parseMediaQuery(queryString);
163     if (!parsedQuery && m_fallbackToDescriptor) {
164         String medium = parseMediaDescriptor(queryString);
165         if (!medium.isNull())
166             parsedQuery = std::make_unique<MediaQuery>(MediaQuery::None, medium, nullptr);
167     }
168     if (!parsedQuery)
169         return false;
170
171     m_queries.append(WTFMove(parsedQuery));
172     return true;
173 }
174
175 bool MediaQuerySet::remove(const String& queryStringToRemove)
176 {
177     CSSParser parser(CSSStrictMode);
178
179     std::unique_ptr<MediaQuery> parsedQuery = parser.parseMediaQuery(queryStringToRemove);
180     if (!parsedQuery && m_fallbackToDescriptor) {
181         String medium = parseMediaDescriptor(queryStringToRemove);
182         if (!medium.isNull())
183             parsedQuery = std::make_unique<MediaQuery>(MediaQuery::None, medium, nullptr);
184     }
185     if (!parsedQuery)
186         return false;
187     
188     return m_queries.removeFirstMatching([&parsedQuery] (const std::unique_ptr<MediaQuery>& query) {
189         return *query == *parsedQuery;
190     });
191 }
192
193 void MediaQuerySet::addMediaQuery(std::unique_ptr<MediaQuery> mediaQuery)
194 {
195     m_queries.append(WTFMove(mediaQuery));
196 }
197
198 String MediaQuerySet::mediaText() const
199 {
200     StringBuilder text;
201     
202     bool first = true;
203     for (size_t i = 0; i < m_queries.size(); ++i) {
204         if (!first)
205             text.appendLiteral(", ");
206         else
207             first = false;
208         text.append(m_queries[i]->cssText());
209     }
210     return text.toString();
211 }
212
213 MediaList::MediaList(MediaQuerySet* mediaQueries, CSSStyleSheet* parentSheet)
214     : m_mediaQueries(mediaQueries)
215     , m_parentStyleSheet(parentSheet)
216     , m_parentRule(0)
217 {
218 }
219
220 MediaList::MediaList(MediaQuerySet* mediaQueries, CSSRule* parentRule)
221     : m_mediaQueries(mediaQueries)
222     , m_parentStyleSheet(0)
223     , m_parentRule(parentRule)
224 {
225 }
226
227 MediaList::~MediaList()
228 {
229 }
230
231 void MediaList::setMediaText(const String& value, ExceptionCode& ec)
232 {
233     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
234
235     bool success = m_mediaQueries->parse(value);
236     if (!success) {
237         ec = SYNTAX_ERR;
238         return;
239     }
240     if (m_parentStyleSheet)
241         m_parentStyleSheet->didMutate();
242 }
243
244 String MediaList::item(unsigned index) const
245 {
246     auto& queries = m_mediaQueries->queryVector();
247     if (index < queries.size())
248         return queries[index]->cssText();
249     return String();
250 }
251
252 void MediaList::deleteMedium(const String& medium, ExceptionCode& ec)
253 {
254     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
255
256     bool success = m_mediaQueries->remove(medium);
257     if (!success) {
258         ec = NOT_FOUND_ERR;
259         return;
260     }
261     if (m_parentStyleSheet)
262         m_parentStyleSheet->didMutate();
263 }
264
265 void MediaList::appendMedium(const String& medium, ExceptionCode& ec)
266 {
267     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
268
269     bool success = m_mediaQueries->add(medium);
270     if (!success) {
271         // FIXME: Should this really be INVALID_CHARACTER_ERR?
272         ec = INVALID_CHARACTER_ERR;
273         return;
274     }
275     if (m_parentStyleSheet)
276         m_parentStyleSheet->didMutate();
277 }
278
279 void MediaList::reattach(MediaQuerySet* mediaQueries)
280 {
281     ASSERT(mediaQueries);
282     m_mediaQueries = mediaQueries;
283 }
284
285 #if ENABLE(RESOLUTION_MEDIA_QUERY)
286 static void addResolutionWarningMessageToConsole(Document* document, const String& serializedExpression, const CSSPrimitiveValue* value)
287 {
288     ASSERT(document);
289     ASSERT(value);
290
291     DEPRECATED_DEFINE_STATIC_LOCAL(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: ")));
292     DEPRECATED_DEFINE_STATIC_LOCAL(String, mediaValueDPI, (ASCIILiteral("dpi")));
293     DEPRECATED_DEFINE_STATIC_LOCAL(String, mediaValueDPCM, (ASCIILiteral("dpcm")));
294     DEPRECATED_DEFINE_STATIC_LOCAL(String, lengthUnitInch, (ASCIILiteral("inch")));
295     DEPRECATED_DEFINE_STATIC_LOCAL(String, lengthUnitCentimeter, (ASCIILiteral("centimeter")));
296
297     String message;
298     if (value->isDotsPerInch())
299         message = String(mediaQueryMessage).replace("%replacementUnits%", mediaValueDPI).replace("%lengthUnit%", lengthUnitInch);
300     else if (value->isDotsPerCentimeter())
301         message = String(mediaQueryMessage).replace("%replacementUnits%", mediaValueDPCM).replace("%lengthUnit%", lengthUnitCentimeter);
302     else
303         ASSERT_NOT_REACHED();
304
305     message.append(serializedExpression);
306
307     document->addConsoleMessage(MessageSource::CSS, MessageLevel::Debug, message);
308 }
309
310 void reportMediaQueryWarningIfNeeded(Document* document, const MediaQuerySet* mediaQuerySet)
311 {
312     if (!mediaQuerySet || !document)
313         return;
314
315     auto& mediaQueries = mediaQuerySet->queryVector();
316     const size_t queryCount = mediaQueries.size();
317
318     if (!queryCount)
319         return;
320
321     for (size_t i = 0; i < queryCount; ++i) {
322         const MediaQuery* query = mediaQueries[i].get();
323         String mediaType = query->mediaType();
324         if (!query->ignored() && !equalIgnoringCase(mediaType, "print")) {
325             auto& expressions = query->expressions();
326             for (size_t j = 0; j < expressions.size(); ++j) {
327                 const MediaQueryExp* exp = expressions.at(j).get();
328                 if (exp->mediaFeature() == MediaFeatureNames::resolutionMediaFeature || exp->mediaFeature() == MediaFeatureNames::max_resolutionMediaFeature || exp->mediaFeature() == MediaFeatureNames::min_resolutionMediaFeature) {
329                     CSSValue* cssValue =  exp->value();
330                     if (is<CSSPrimitiveValue>(cssValue)) {
331                         CSSPrimitiveValue& primitiveValue = downcast<CSSPrimitiveValue>(*cssValue);
332                         if (primitiveValue.isDotsPerInch() || primitiveValue.isDotsPerCentimeter())
333                             addResolutionWarningMessageToConsole(document, mediaQuerySet->mediaText(), &primitiveValue);
334                     }
335                 }
336             }
337         }
338     }
339 }
340 #endif
341
342 }