Remove @media rules.

sky/engine/core/css/parser/CSSGrammar.y

 %{
 
 /*
  *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
  *  Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  *  Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *  Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  *  Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
@@ skipping 11 matching lines @@
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */
 
 #include "config.h"
 
 #include "CSSPropertyNames.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
-#include "core/css/MediaList.h"
-#include "core/css/MediaQueryExp.h"
 #include "core/css/StyleKeyframe.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleRuleKeyframes.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/parser/CSSParserMode.h"
 #include "core/dom/Document.h"
-#include "sky/engine/core/css/MediaList.h"
 #include "wtf/FastMalloc.h"
 #include <stdlib.h>
 #include <string.h>
 
 using namespace blink;
 
 #define YYMALLOC fastMalloc
 #define YYFREE fastFree
 
 #define YYENABLE_NLS 0
@@ skipping 14 matching lines @@
 
 %union {
     bool boolean;
     char character;
     int integer;
     double number;
     CSSParserString string;
 
     StyleRuleBase* rule;
     // The content of the three below HeapVectors are guaranteed to be kept alive by
-    // the corresponding m_parsedRules, m_floatingMediaQueryExpList, and m_parsedKeyFrames
+    // the corresponding m_parsedRules, and m_parsedKeyFrames
     // lists in BisonCSSParser.h.
     Vector<RefPtr<StyleRuleBase> >* ruleList;
-    Vector<OwnPtr<MediaQueryExp> >* mediaQueryExpList;
     Vector<RefPtr<StyleKeyframe> >* keyframeRuleList;
     CSSParserSelector* selector;
     Vector<OwnPtr<CSSParserSelector> >* selectorList;
     CSSSelector::AttributeMatchType attributeMatchType;
-    MediaQuerySet* mediaList;
-    MediaQuery* mediaQuery;
-    MediaQuery::Restrictor mediaQueryRestrictor;
-    MediaQueryExp* mediaQueryExp;
     CSSParserValue value;
     CSSParserValueList* valueList;
     StyleKeyframe* keyframe;
     float val;
     CSSPropertyID id;
     CSSParserLocation location;
 }
 
 %{
 
@@ skipping 69 matching lines @@
 
 %nonassoc <string> HEX
 %nonassoc <string> IDSEL
 %nonassoc ':'
 %nonassoc '.'
 %nonassoc '['
 %nonassoc <string> '*'
 %nonassoc error
 %left '|'
 
-%token MEDIA_SYM
 %token SUPPORTS_SYM
 %token FONT_FACE_SYM
 %token CHARSET_SYM
 %token INTERNAL_DECLS_SYM
-%token INTERNAL_MEDIALIST_SYM
 %token INTERNAL_RULE_SYM
 %token INTERNAL_SELECTOR_SYM
 %token INTERNAL_VALUE_SYM
 %token INTERNAL_KEYFRAME_RULE_SYM
 %token INTERNAL_KEYFRAME_KEY_LIST_SYM
 %token INTERNAL_SUPPORTS_CONDITION_SYM
 %token KEYFRAMES_SYM
 
 %token ATKEYWORD
 
 %token IMPORTANT_SYM
-%token MEDIA_ONLY
-%token MEDIA_NOT
-%token MEDIA_AND
-%token MEDIA_OR
 
 %token SUPPORTS_NOT
 %token SUPPORTS_AND
 %token SUPPORTS_OR
 
 %token <number> CHS
 %token <number> EMS
 %token <number> EXS
 %token <number> PXS
 %token <number> CMS
@@ skipping 25 matching lines @@
 
 %token <string> URI
 %token <string> FUNCTION
 %token <string> NOTFUNCTION
 %token <string> CALCFUNCTION
 %token <string> HOSTFUNCTION
 
 %token <string> UNICODERANGE
 
 %type <rule> ruleset
-%type <rule> media
 %type <rule> font_face
 %type <rule> keyframes
 %type <rule> rule
 %type <rule> valid_rule
 %type <ruleList> block_rule_body
 %type <ruleList> block_rule_list
 %type <rule> block_rule
 %type <rule> block_valid_rule
 %type <rule> supports
 %type <boolean> keyframes_rule_start
 
 %type <string> ident_or_string
-%type <string> medium
-
-%type <mediaList> media_list
-%type <mediaList> maybe_media_list
-%type <mediaList> mq_list
-%type <mediaQuery> media_query
-%type <mediaQuery> valid_media_query
-%type <mediaQueryRestrictor> maybe_media_restrictor
-%type <valueList> maybe_media_value
-%type <mediaQueryExp> media_query_exp
-%type <mediaQueryExpList> media_query_exp_list
-%type <mediaQueryExpList> maybe_and_media_query_exp_list
 
 %type <boolean> supports_condition
 %type <boolean> supports_condition_in_parens
 %type <boolean> supports_negation
 %type <boolean> supports_conjunction
 %type <boolean> supports_disjunction
 %type <boolean> supports_declaration_condition
 
 %type <string> keyframe_name
 %type <keyframe> keyframe_rule
@@ skipping 47 matching lines @@
 %type <value> track_names_list
 
 %%
 
 stylesheet:
     maybe_charset maybe_sgml rule_list
   | internal_decls
   | internal_rule
   | internal_selector
   | internal_value
-  | internal_medialist
   | internal_keyframe_rule
   | internal_keyframe_key_list
   | internal_supports_condition
   ;
 
 internal_rule:
     INTERNAL_RULE_SYM maybe_space valid_rule maybe_space TOKEN_EOF {
         parser->m_rule = $3;
     }
 ;
@@ skipping 19 matching lines @@
 internal_value:
     INTERNAL_VALUE_SYM maybe_space expr TOKEN_EOF {
         parser->m_valueList = parser->sinkFloatingValueList($3);
         int oldParsedProperties = parser->m_parsedProperties.size();
         if (!parser->parseValue(parser->m_id, parser->m_important))
             parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties);
         parser->m_valueList = nullptr;
     }
 ;
 
-internal_medialist:
-    INTERNAL_MEDIALIST_SYM maybe_space location_label maybe_media_list TOKEN_EOF {
-        parser->m_mediaList = $4;
-    }
-;
-
 internal_selector:
     INTERNAL_SELECTOR_SYM maybe_space selector_list TOKEN_EOF {
         if (parser->m_selectorListForParseSelector)
             parser->m_selectorListForParseSelector->adoptSelectorVector(*$3);
     }
 ;
 
 internal_supports_condition:
     INTERNAL_SUPPORTS_CONDITION_SYM maybe_space supports_condition TOKEN_EOF {
         parser->m_supportsCondition = $3;
@@ skipping 48 matching lines @@
 rule_list:
    /* empty */
  | rule_list rule maybe_sgml {
      if ($2 && parser->m_styleSheet)
          parser->m_styleSheet->parserAppendRule($2);
  }
  ;
 
 valid_rule:
     ruleset
-  | media
   | font_face
   | keyframes
   | supports
   ;
 
 before_rule:
     /* empty */ {
         parser->startRule();
     }
   ;
@@ skipping 24 matching lines @@
 
 block_rule_recovery:
     before_rule invalid_rule_header {
         parser->endRule(false);
     }
   ;
 
 block_valid_rule:
     ruleset
   | font_face
-  | media
   | keyframes
   | supports
   ;
 
 block_rule:
     before_rule block_valid_rule {
         $$ = $2;
         parser->endRule(!!$$);
     }
   | before_rule invalid_rule {
         $$ = 0;
         parser->endRule(false);
     }
   ;
 
-maybe_media_value:
-    /*empty*/ {
-        $$ = 0;
-    }
-    | ':' maybe_space expr {
-        $$ = $3;
-    }
-    ;
-
-media_query_exp:
-    '(' maybe_space IDENT maybe_space maybe_media_value closing_parenthesis {
-        parser->tokenToLowerCase($3);
-        $$ = parser->createFloatingMediaQueryExp($3, $5);
-        if (!$$)
-            YYERROR;
-    }
-    | '(' error error_recovery closing_parenthesis {
-        YYERROR;
-    }
-    ;
-
-media_query_exp_list:
-    media_query_exp {
-        $$ = parser->createFloatingMediaQueryExpList();
-        $$->append(parser->sinkFloatingMediaQueryExp($1));
-    }
-    | media_query_exp_list maybe_space MEDIA_AND maybe_space media_query_exp {
-        $$ = $1;
-        $$->append(parser->sinkFloatingMediaQueryExp($5));
-    }
-    ;
-
-maybe_and_media_query_exp_list:
-    maybe_space {
-        $$ = parser->createFloatingMediaQueryExpList();
-    }
-    | maybe_space MEDIA_AND maybe_space media_query_exp_list maybe_space {
-        $$ = $4;
-    }
-    ;
-
-maybe_media_restrictor:
-    /*empty*/ {
-        $$ = MediaQuery::None;
-    }
-    | MEDIA_ONLY maybe_space {
-        $$ = MediaQuery::Only;
-    }
-    | MEDIA_NOT maybe_space {
-        $$ = MediaQuery::Not;
-    }
-    ;
-
-valid_media_query:
-    media_query_exp_list maybe_space {
-        $$ = parser->createFloatingMediaQuery(parser->sinkFloatingMediaQueryExpList($1));
-    }
-    | maybe_media_restrictor medium maybe_and_media_query_exp_list {
-        parser->tokenToLowerCase($2);
-        $$ = parser->createFloatingMediaQuery($1, $2, parser->sinkFloatingMediaQueryExpList($3));
-    }
-    ;
-
-media_query:
-    valid_media_query
-    | valid_media_query error error_location rule_error_recovery {
-        parser->reportError(parser->lastLocationLabel(), InvalidMediaQueryCSSError);
-        $$ = parser->createFloatingNotAllQuery();
-    }
-    | error error_location rule_error_recovery {
-        parser->reportError(parser->lastLocationLabel(), InvalidMediaQueryCSSError);
-        $$ = parser->createFloatingNotAllQuery();
-    }
-    ;
-
-maybe_media_list:
-    /* empty */ {
-        $$ = parser->createMediaQuerySet();
-    }
-    | media_list
-    ;
-
-media_list:
-    media_query {
-        $$ = parser->createMediaQuerySet();
-        $$->addMediaQuery(parser->sinkFloatingMediaQuery($1));
-    }
-    | mq_list media_query {
-        $$ = $1;
-        $$->addMediaQuery(parser->sinkFloatingMediaQuery($2));
-    }
-    | mq_list {
-        $$ = $1;
-        $$->addMediaQuery(parser->sinkFloatingMediaQuery(parser->createFloatingNotAllQuery()));
-    }
-    ;
-
-mq_list:
-    media_query ',' maybe_space location_label {
-        $$ = parser->createMediaQuerySet();
-        $$->addMediaQuery(parser->sinkFloatingMediaQuery($1));
-    }
-    | mq_list media_query ',' maybe_space location_label {
-        $$ = $1;
-        $$->addMediaQuery(parser->sinkFloatingMediaQuery($2));
-    }
-    ;
-
 at_rule_body_start:
     /* empty */ {
         parser->startRuleBody();
     }
     ;
 
-before_media_rule:
-    /* empty */ {
-        parser->startRuleHeader(CSSRuleSourceData::MEDIA_RULE);
-    }
-    ;
-
 at_rule_header_end_maybe_space:
     maybe_space {
         parser->endRuleHeader();
     }
     ;
 
-media_rule_start:
-    before_media_rule MEDIA_SYM maybe_space;
-
-media:
-    media_rule_start maybe_media_list '{' at_rule_header_end at_rule_body_start maybe_space block_rule_body closing_brace {
-        $$ = parser->createMediaRule($2, $7);
-    }
-    ;
-
-medium:
-  IDENT
-  ;
-
 supports:
     before_supports_rule SUPPORTS_SYM maybe_space supports_condition at_supports_rule_header_end '{' at_rule_body_start maybe_space block_rule_body closing_brace {
         $$ = parser->createSupportsRule($4, $9);
     }
     ;
 
 before_supports_rule:
     /* empty */ {
         parser->startRuleHeader(CSSRuleSourceData::SUPPORTS_RULE);
         parser->markSupportsRuleHeaderStart();
@@ skipping 759 matching lines @@
         parser->reportError($1, InvalidRuleCSSError);
     }
   ;
 
 invalid_rule:
     error error_location rule_error_recovery at_invalid_rule_header_end invalid_block {
         parser->reportError($2, InvalidRuleCSSError);
     }
   | regular_invalid_at_rule_header at_invalid_rule_header_end ';'
   | regular_invalid_at_rule_header at_invalid_rule_header_end invalid_block
-  | media_rule_start maybe_media_list ';'
     ;
 
 invalid_rule_header:
     error error_location rule_error_recovery at_invalid_rule_header_end {
         parser->reportError($2, InvalidRuleCSSError);
     }
   | regular_invalid_at_rule_header at_invalid_rule_header_end
-  | media_rule_start maybe_media_list
     ;
 
 at_invalid_rule_header_end:
    /* empty */ {
        parser->endInvalidRuleHeader();
    }
    ;
 
 invalid_block:
     '{' error_recovery closing_brace {
@@ skipping 31 matching lines @@
     ;
 
 rule_error_recovery:
     /* empty */
   | rule_error_recovery error
   | rule_error_recovery invalid_square_brackets_block
   | rule_error_recovery invalid_parentheses_block
     ;
 
 %%