A sizes attribute parser

Source/core/css/parser/SizesAttributeParser.cpp

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "config.h"
+#include "SizesAttributeParser.h"
+
+#include "core/css/MediaQueryEvaluator.h"
+#include "core/css/parser/MediaQueryTokenizer.h"
+
+namespace WebCore {
+
+enum { EffectiveSizeDefaultValue = 300 };

[eseidel, 2014/04/08 06:02:14]

I know you were encouraged to do these as Enums before.  I'm not really sure
why.  I probably would have used const int, but this is also OK just feels odd
to me.  I wish we had the reasoning one way or the other documented in our style
guide...

[rune, 2014/04/08 10:34:42]

That would have been me. I based it on how it's mostly done elsewhere in Blink.
const int members use memory, or?

+
+int SizesAttributeParser::findEffectiveSize(const String& attribute, PassRefPtr<MediaValues> mediaValues)
+{
+    Vector<MediaQueryToken> tokens;
+    SizesAttributeParser parser(mediaValues);
+
+    MediaQueryTokenizer::tokenize(attribute, tokens);
+    if (!parser.parseImpl(tokens))

[eseidel, 2014/04/08 06:02:14]

Why parseImpl and not just parse?

+        return EffectiveSizeDefaultValue;
+    return parser.effectiveSize();
+}
+
+int SizesAttributeParser::calculateLengthInPixels(TokenIterator startToken, TokenIterator endToken)
+{
+    // FIXME - make this actually do something!
+    return 0;
+}
+
+static void goBackWhileWhitespaceToken(TokenIterator& token, TokenIterator startToken)

[eseidel, 2014/04/08 06:02:14]

Other parser have used:

template<type UntilFunction>
goBackUntil<UntilFunction>()...

I guess it depends on if you'll need others of these.

+{
+    while (token != startToken && token->type() == WhitespaceToken)
+        --token;
+}
+
+static void goBackUntilWhitespaceToken(TokenIterator& token, TokenIterator startToken)
+{
+    while (token != startToken && token->type() != WhitespaceToken)
+        --token;
+}
+
+bool SizesAttributeParser::mediaConditionMatches(PassRefPtr<MediaQuerySet> mediaCondition)
+{
+    // FIXME: How do I handle non-screen media types here?
+    // FIXME2: Replaces "screen" with a static string
+    MediaQueryEvaluator mediaQueryEvaluator("screen", m_mediaValues);

[eseidel, 2014/04/08 06:02:14]

IIRC you have some StaticStrings for media types, like screen?

+    return mediaQueryEvaluator.eval(mediaCondition.get());
+}
+
+bool SizesAttributeParser::parseMediaConditionAndLength(TokenIterator startToken, TokenIterator endToken)
+{
+    TokenIterator lengthTokenStart;
+    TokenIterator lengthTokenEnd;
+
+    goBackWhileWhitespaceToken(endToken, startToken);

[eseidel, 2014/04/08 06:02:14]

I see, so these would be "reverseFind" in a string, but we have a token stream
instead, right?

+    lengthTokenEnd = endToken;
+    goBackUntilWhitespaceToken(endToken, startToken);
+    lengthTokenStart = endToken;
+    ++lengthTokenStart;
+    int length = calculateLengthInPixels(lengthTokenStart, lengthTokenEnd);
+    RefPtr<MediaQuerySet> mediaCondition = MediaQueryParser::parseMediaCondition(startToken, endToken);
+    if (!mediaCondition || mediaCondition->queryVector().isEmpty())
+        m_defaultLength = length;
+    else if (mediaConditionMatches(mediaCondition))
+        m_length = length;
+    else
+        return false;
+    return true;
+}
+
+bool SizesAttributeParser::parseImpl(Vector<MediaQueryToken>& tokens)
+{
+    TokenIterator startToken = tokens.begin();
+    TokenIterator endToken;
+    // Split on a comma token, and send the result tokens to be parsed as (media-condition, length) pairs
+    for (TokenIterator token = tokens.begin(); token != tokens.end(); ++token) {
+        if (token->type() == CommaToken) {
+            endToken = token;
+            --endToken;
+            if (parseMediaConditionAndLength(startToken, endToken))
+                return true;
+            startToken = token;
+            ++startToken;
+        }
+    }
+    return parseMediaConditionAndLength(startToken, tokens.end());
+}
+
+int SizesAttributeParser::effectiveSize()
+{
+    // FIXME - implement the "find effective size" algorithm!
+    return 0;
+}
+
+} // namespace
+