Remove @media rules.

sky/engine/core/css/parser/CSSTokenizer-in.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/css/parser/CSSTokenizer.h"
 
-#include "sky/engine/core/css/MediaQuery.h"
 #include "sky/engine/core/css/StyleRule.h"
 #include "sky/engine/core/css/parser/BisonCSSParser.h"
 #include "sky/engine/core/css/parser/CSSParserValues.h"
 #include "sky/engine/core/html/parser/HTMLParserIdioms.h"
 
 namespace blink {
 
 #include "gen/sky/core/CSSGrammar.h"
 
 enum CharacterType {
     // Types for the main switch.
 
     // The first 4 types must be grouped together, as they
     // represent the allowed chars in an identifier.
     CharacterCaselessU,
     CharacterIdentifierStart,
     CharacterNumber,
     CharacterDash,
 
     CharacterOther,
     CharacterNull,
     CharacterWhiteSpace,
-    CharacterEndMediaQueryOrSupports,
+    CharacterEndSupports,
     CharacterEndNthChild,
     CharacterQuote,
     CharacterExclamationMark,
     CharacterHashmark,
     CharacterDollar,
     CharacterAsterisk,
     CharacterPlus,
     CharacterDot,
     CharacterSlash,
     CharacterLess,
@@ skipping 58 matching lines @@
 /*  49 - 1                  */ CharacterNumber,
 /*  50 - 2                  */ CharacterNumber,
 /*  51 - 3                  */ CharacterNumber,
 /*  52 - 4                  */ CharacterNumber,
 /*  53 - 5                  */ CharacterNumber,
 /*  54 - 6                  */ CharacterNumber,
 /*  55 - 7                  */ CharacterNumber,
 /*  56 - 8                  */ CharacterNumber,
 /*  57 - 9                  */ CharacterNumber,
 /*  58 - :                  */ CharacterOther,
-/*  59 - ;                  */ CharacterEndMediaQueryOrSupports,
+/*  59 - ;                  */ CharacterEndSupports,
 /*  60 - <                  */ CharacterLess,
 /*  61 - =                  */ CharacterOther,
 /*  62 - >                  */ CharacterOther,
 /*  63 - ?                  */ CharacterOther,
 /*  64 - @                  */ CharacterAt,
 /*  65 - A                  */ CharacterIdentifierStart,
 /*  66 - B                  */ CharacterIdentifierStart,
 /*  67 - C                  */ CharacterIdentifierStart,
 /*  68 - D                  */ CharacterIdentifierStart,
 /*  69 - E                  */ CharacterIdentifierStart,
@@ skipping 43 matching lines @@
 /* 113 - q                  */ CharacterIdentifierStart,
 /* 114 - r                  */ CharacterIdentifierStart,
 /* 115 - s                  */ CharacterIdentifierStart,
 /* 116 - t                  */ CharacterIdentifierStart,
 /* 117 - u                  */ CharacterCaselessU,
 /* 118 - v                  */ CharacterIdentifierStart,
 /* 119 - w                  */ CharacterIdentifierStart,
 /* 120 - x                  */ CharacterIdentifierStart,
 /* 121 - y                  */ CharacterIdentifierStart,
 /* 122 - z                  */ CharacterIdentifierStart,
-/* 123 - {                  */ CharacterEndMediaQueryOrSupports,
+/* 123 - {                  */ CharacterEndSupports,
 /* 124 - |                  */ CharacterVerticalBar,
 /* 125 - }                  */ CharacterOther,
 /* 126 - ~                  */ CharacterTilde,
 /* 127 - Delete             */ CharacterOther,
 };
 
 // Utility functions for the CSS tokenizer.
 
 template <typename CharacterType>
 static inline bool isCSSLetter(CharacterType character)
@@ skipping 542 matching lines @@
         }
         CASE("host") {
             m_token = HOSTFUNCTION;
             return true;
         }
     }
     return false;
 }
 
 template <typename CharacterType>
-inline void CSSTokenizer::detectMediaQueryToken(int length)
-{
-    ASSERT(m_parsingMode == MediaQueryMode);
-    CharacterType* name = tokenStart<CharacterType>();
-
-    SWITCH(name, length) {
-        CASE("and") {
-            m_token = MEDIA_AND;
-        }
-        CASE("not") {
-            m_token = MEDIA_NOT;
-        }
-        CASE("only") {
-            m_token = MEDIA_ONLY;
-        }
-        CASE("or") {
-            m_token = MEDIA_OR;
-        }
-    }
-}
-
-template <typename CharacterType>
 inline void CSSTokenizer::detectNumberToken(CharacterType* type, int length)
 {
     ASSERT(length > 0);
 
     SWITCH(type, length) {
         CASE("cm") {
             m_token = CMS;
         }
         CASE("ch") {
             m_token = CHS;
@@ skipping 105 matching lines @@
         CASE("charset") {
             if (name - 1 == dataStart<CharacterType>())
                 m_token = CHARSET_SYM;
         }
         CASE("font-face") {
             m_token = FONT_FACE_SYM;
         }
         CASE("keyframes") {
             m_token = KEYFRAMES_SYM;
         }
-        CASE("media") {
-            m_parsingMode = MediaQueryMode;
-            m_token = MEDIA_SYM;
-        }
         CASE("supports") {
             m_parsingMode = SupportsMode;
             m_token = SUPPORTS_SYM;
         }
         CASE("-internal-rule") {
             if (LIKELY(!hasEscape && m_internal))
                 m_token = INTERNAL_RULE_SYM;
         }
         CASE("-internal-decls") {
             if (LIKELY(!hasEscape && m_internal))
                 m_token = INTERNAL_DECLS_SYM;
         }
         CASE("-internal-value") {
             if (LIKELY(!hasEscape && m_internal))
                 m_token = INTERNAL_VALUE_SYM;
         }
         CASE("-internal-selector") {
             if (LIKELY(!hasEscape && m_internal))
                 m_token = INTERNAL_SELECTOR_SYM;
         }
-        CASE("-internal-medialist") {
-            if (!m_internal)
-                return;
-            m_parsingMode = MediaQueryMode;
-            m_token = INTERNAL_MEDIALIST_SYM;
-        }
         CASE("-internal-keyframe-rule") {
             if (LIKELY(!hasEscape && m_internal))
                 m_token = INTERNAL_KEYFRAME_RULE_SYM;
         }
         CASE("-internal-keyframe-key-list") {
             if (!m_internal)
                 return;
             m_token = INTERNAL_KEYFRAME_KEY_LIST_SYM;
         }
         CASE("-internal-supports-condition") {
@@ skipping 81 matching lines @@
 
             if (m_token == URI) {
                 m_token = FUNCTION;
                 // Check whether it is really an URI.
                 if (yylval->string.is8Bit())
                     parseURI<LChar>(yylval->string);
                 else
                     parseURI<UChar>(yylval->string);
             }
         } else if (UNLIKELY(m_parsingMode != NormalMode) && !hasEscape) {
-            if (m_parsingMode == MediaQueryMode) {
-                detectMediaQueryToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
-            } else if (m_parsingMode == SupportsMode) {
+            if (m_parsingMode == SupportsMode) {
                 detectSupportsToken<SrcCharacterType>(result - tokenStart<SrcCharacterType>());
             }
         }
         break;
 
     case CharacterDot:
         if (!isASCIIDigit(currentCharacter<SrcCharacterType>()[0]))
             break;
         // Fall through to CharacterNumber.
 
@@ skipping 75 matching lines @@
         m_token = WHITESPACE;
         // Might start with a '\n'.
         --currentCharacter<SrcCharacterType>();
         do {
             if (*currentCharacter<SrcCharacterType>() == '\n')
                 ++m_lineNumber;
             ++currentCharacter<SrcCharacterType>();
         } while (*currentCharacter<SrcCharacterType>() <= ' ' && (typesOfASCIICharacters[*currentCharacter<SrcCharacterType>()] == CharacterWhiteSpace));
         break;
 
-    case CharacterEndMediaQueryOrSupports:
-        if (m_parsingMode == MediaQueryMode || m_parsingMode == SupportsMode)
+    case CharacterEndSupports:
+        if (m_parsingMode == SupportsMode)
             m_parsingMode = NormalMode;
         break;
 
     case CharacterQuote:
         if (checkAndSkipString(currentCharacter<SrcCharacterType>(), m_token, AbortIfInvalid)) {
             ++result;
             parseString<SrcCharacterType>(result, yylval->string, m_token);
             m_token = STRING;
         }
         break;
@@ skipping 197 matching lines @@
     m_dataStart16[length - 1] = 0;
 
     m_is8BitSource = false;
     m_currentCharacter8 = 0;
     m_currentCharacter16 = m_dataStart16.get();
     setTokenStart<UChar>(m_currentCharacter16);
     m_lexFunc = &CSSTokenizer::realLex<UChar>;
 }
 
 } // namespace blink