Get Media Query parser to handle parens, brackets and braces blocks correctly

Source/core/css/parser/MediaQueryParser.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 "core/css/parser/MediaQueryParser.h"
 
 #include "MediaTypeNames.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/parser/MediaQueryTokenizer.h"
 
 namespace WebCore {
 
 PassRefPtrWillBeRawPtr<MediaQuerySet> MediaQueryParser::parse(const String& queryString)
 {
     return MediaQueryParser(queryString).parseImpl();
 }
 
 const MediaQueryParser::State MediaQueryParser::ReadRestrictor = &MediaQueryParser::readRestrictor;
 const MediaQueryParser::State MediaQueryParser::ReadMediaType = &MediaQueryParser::readMediaType;
 const MediaQueryParser::State MediaQueryParser::ReadAnd = &MediaQueryParser::readAnd;
 const MediaQueryParser::State MediaQueryParser::ReadFeatureStart = &MediaQueryParser::readFeatureStart;
 const MediaQueryParser::State MediaQueryParser::ReadFeature = &MediaQueryParser::readFeature;
 const MediaQueryParser::State MediaQueryParser::ReadFeatureColon = &MediaQueryParser::readFeatureColon;
 const MediaQueryParser::State MediaQueryParser::ReadFeatureValue = &MediaQueryParser::readFeatureValue;
 const MediaQueryParser::State MediaQueryParser::ReadFeatureEnd = &MediaQueryParser::readFeatureEnd;
 const MediaQueryParser::State MediaQueryParser::SkipUntilComma = &MediaQueryParser::skipUntilComma;
-const MediaQueryParser::State MediaQueryParser::SkipUntilParenthesis = &MediaQueryParser::skipUntilParenthesis;
+const MediaQueryParser::State MediaQueryParser::SkipUntilBlockEnd = &MediaQueryParser::skipUntilBlockEnd;
 const MediaQueryParser::State MediaQueryParser::Done = &MediaQueryParser::done;
 
 // FIXME: Replace the MediaQueryTokenizer with a generic CSSTokenizer, once there is one,
 // or better yet, replace the MediaQueryParser with a generic thread-safe CSS parser.
 MediaQueryParser::MediaQueryParser(const String& queryString)
     : m_state(&MediaQueryParser::readRestrictor)
     , m_querySet(MediaQuerySet::create())
 {
     MediaQueryTokenizer::tokenize(queryString, m_tokens);
 }
@@ skipping 65 matching lines @@
 }
 
 void MediaQueryParser::readFeatureColon(MediaQueryTokenType type, TokenIterator& token)
 {
     if (type == ColonToken) {
         m_state = ReadFeatureValue;
     } else if (type == RightParenthesisToken || type == EOFToken) {
         --token;
         m_state = ReadFeatureEnd;
     } else {
-        m_state = SkipUntilParenthesis;
+        m_state = SkipUntilBlockEnd;
     }
 }
 
 void MediaQueryParser::readFeatureValue(MediaQueryTokenType type, TokenIterator& token)
 {
     if (type == DimensionToken && token->unitType() == CSSPrimitiveValue::CSS_UNKNOWN) {
         m_state = SkipUntilComma;
     } else {
         m_mediaQueryData.addParserValue(type, *token);
         m_state = ReadFeatureEnd;
     }
 }
 
 void MediaQueryParser::readFeatureEnd(MediaQueryTokenType type, TokenIterator& token)
 {
     if (type == RightParenthesisToken || type == EOFToken) {
         if (m_mediaQueryData.addExpression())
             m_state = ReadAnd;
         else
             m_state = SkipUntilComma;
     } else if (type == DelimiterToken && token->delimiter() == '/') {
         m_mediaQueryData.addParserValue(type, *token);
         m_state = ReadFeatureValue;
     } else {
-        m_state = SkipUntilParenthesis;
+        m_state = SkipUntilBlockEnd;
     }
 }
 
 void MediaQueryParser::skipUntilComma(MediaQueryTokenType type, TokenIterator& token)
 {
     if (type == CommaToken || type == EOFToken) {
         m_state = ReadRestrictor;
         m_mediaQueryData.clear();
         m_querySet->addMediaQuery(MediaQuery::createNotAll());
     }
 }
 
-void MediaQueryParser::skipUntilParenthesis(MediaQueryTokenType type, TokenIterator& token)
+void MediaQueryParser::skipUntilBlockEnd(MediaQueryTokenType type, TokenIterator& token)
 {
-    if (type == RightParenthesisToken)
+    if (m_blockStack.isEmpty())

[eseidel, 2014/04/01 21:15:08]

I'm not sure I understand this.  I guess it depends on how it's called?  What
states can cause us to start skipping? do tdhey all want this comma behavior? 
Maybe this comma behavior should be explicit in the callsites?

         m_state = SkipUntilComma;
 }
 
 void MediaQueryParser::done(MediaQueryTokenType type, TokenIterator& token) { }
 
+void MediaQueryParser::popIfBlockMatches(Vector<BlockType>& blockStack, BlockType type)
+{
+    if (!blockStack.isEmpty() && blockStack.last() == type)
+        blockStack.removeLast();
+}
+
+bool MediaQueryParser::observeBlock(BlockParameters& parameters, MediaQueryTokenType type)
+{
+    if (type == parameters.lefttoken) {
+        if (parameters.stateChange == ModifyState)
+            m_state = SkipUntilBlockEnd;
+        m_blockStack.append(parameters.blockType);
+    } else if (type == parameters.righttoken) {
+        popIfBlockMatches(m_blockStack, parameters.blockType);
+    } else {
+        return false;
+    }
+    return true;
+}
+
+void MediaQueryParser::observeBlocks(MediaQueryTokenType type)
+{
+    const unsigned blockParametersNumber = 3;
+    BlockParameters blockParameterSet[blockParametersNumber] = {
+        { LeftParenthesisToken, RightParenthesisToken, ParenthesisBlock, DoNotModifyState },
+        { LeftBracketToken, RightBracketToken, BracketsBlock, ModifyState },

[eseidel, 2014/04/01 21:15:08]

What does "modify state" mean?  It appears to me "colapse verything between
start and end into a single token?"

+        { LeftBraceToken, RightBraceToken, BracesBlock, ModifyState }
+    };
+
+    for (unsigned i = 0; i < blockParametersNumber; ++i) {
+        if (observeBlock(blockParameterSet[i], type))
+            break;
+    }
+}
+
 void MediaQueryParser::processToken(TokenIterator& token)
 {
     MediaQueryTokenType type = token->type();
 
+    observeBlocks(type);
+
     // Call the function that handles current state
     if (type != WhitespaceToken && type != CommentToken)
         ((this)->*(m_state))(type, token);
 }
 
 // The state machine loop
 PassRefPtrWillBeRawPtr<MediaQuerySet> MediaQueryParser::parseImpl()
 {
     for (Vector<MediaQueryToken>::iterator token = m_tokens.begin(); token != m_tokens.end(); ++token)
         processToken(token);
@@ skipping 60 matching lines @@
     m_valueList.addValue(value);
 }
 
 void MediaQueryData::setMediaType(const String& mediaType)
 {
     m_mediaType = mediaType;
     m_mediaTypeSet = true;
 }
 
 } // namespace WebCore