⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 118659 in webkit


Ignore:
Timestamp:
May 28, 2012, 2:14:38 AM (14 years ago)
Author:
zandobersek@gmail.com
Message:

Unreviewed, rolling out r118650.
​http://trac.webkit.org/changeset/118650
​https://bugs.webkit.org/show_bug.cgi?id=87639

Patch caused massive failures throughout the builders
(Requested by zdobersek on #webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2012-05-28

  • css/MediaQuery.cpp:

(WebCore):
(WebCore::MediaQuery::serialize):
(WebCore::MediaQuery::MediaQuery):
(WebCore::MediaQuery::cssText):

  • css/MediaQuery.h:

(WebCore::MediaQuery::expressions):
(WebCore::MediaQuery::mediaType):
(MediaQuery):
(WebCore::MediaQuery::copy):

  • css/MediaQueryEvaluator.cpp:

(WebCore::MediaQueryEvaluator::MediaQueryEvaluator):
(WebCore::MediaQueryEvaluator):
(WebCore::MediaQueryEvaluator::eval):
(WebCore::aspect_ratioMediaFeatureEval):
(WebCore::device_aspect_ratioMediaFeatureEval):
(WebCore::transform_3dMediaFeatureEval):
(WebCore::view_modeMediaFeatureEval):
(WebCore::createFunctionMap):

  • css/MediaQueryEvaluator.h:

(WebCore):
(MediaQueryEvaluator):

  • css/StyleResolver.cpp:

(WebCore):
(WebCore::StyleResolver::collectMatchingRulesForList):

  • css/StyleResolver.h:

(MediaQueryResult):
(WebCore::MediaQueryResult::MediaQueryResult):
(WebCore):
(StyleResolver):

Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r118657 r118659  
     12012-05-28  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r118650.
     4        http://trac.webkit.org/changeset/118650
     5        https://bugs.webkit.org/show_bug.cgi?id=87639
     6
     7        Patch caused massive failures throughout the builders
     8        (Requested by zdobersek on #webkit).
     9
     10        * css/MediaQuery.cpp:
     11        (WebCore):
     12        (WebCore::MediaQuery::serialize):
     13        (WebCore::MediaQuery::MediaQuery):
     14        (WebCore::MediaQuery::cssText):
     15        * css/MediaQuery.h:
     16        (WebCore::MediaQuery::expressions):
     17        (WebCore::MediaQuery::mediaType):
     18        (MediaQuery):
     19        (WebCore::MediaQuery::copy):
     20        * css/MediaQueryEvaluator.cpp:
     21        (WebCore::MediaQueryEvaluator::MediaQueryEvaluator):
     22        (WebCore::MediaQueryEvaluator):
     23        (WebCore::MediaQueryEvaluator::eval):
     24        (WebCore::aspect_ratioMediaFeatureEval):
     25        (WebCore::device_aspect_ratioMediaFeatureEval):
     26        (WebCore::transform_3dMediaFeatureEval):
     27        (WebCore::view_modeMediaFeatureEval):
     28        (WebCore::createFunctionMap):
     29        * css/MediaQueryEvaluator.h:
     30        (WebCore):
     31        (MediaQueryEvaluator):
     32        * css/StyleResolver.cpp:
     33        (WebCore):
     34        (WebCore::StyleResolver::collectMatchingRulesForList):
     35        * css/StyleResolver.h:
     36        (MediaQueryResult):
     37        (WebCore::MediaQueryResult::MediaQueryResult):
     38        (WebCore):
     39        (StyleResolver):
     40
    1412012-05-28  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
    242

  • trunk/Source/WebCore/css/MediaQuery.cpp

    r118650 r118659  
    3636namespace WebCore {
    3737
     38// http://dev.w3.org/csswg/cssom/#serialize-a-media-query
    3839String MediaQuery::serialize() const
    3940{
    … …  
    6667        result.append(m_expressions->at(i)->serialize());
    6768    }
    68 
    6969    return result.toString();
    7070}
    … …  
    7575}
    7676
    77 MediaQuery::MediaQuery(Restrictor restrictor, const String& mediaType, PassOwnPtr<ExpressionVector> expressions)
    78     : m_restrictor(restrictor)
     77
     78MediaQuery::MediaQuery(Restrictor r, const String& mediaType, PassOwnPtr<Vector<OwnPtr<MediaQueryExp> > > exprs)
     79    : m_restrictor(r)
    7980    , m_mediaType(mediaType.lower())
    80     , m_expressions(expressions)
     81    , m_expressions(exprs)
    8182    , m_ignored(false)
    8283{
    8384    if (!m_expressions) {
    84         m_expressions = adoptPtr(new ExpressionVector);
     85        m_expressions = adoptPtr(new Vector<OwnPtr<MediaQueryExp> >);
    8586        return;
    8687    }
    8788
    88     ExpressionVector& vector = *m_expressions;
     89    nonCopyingSort(m_expressions->begin(), m_expressions->end(), expressionCompare);
    8990
    90     nonCopyingSort(vector.begin(), vector.end(), expressionCompare);
     91    // remove all duplicated expressions
     92    String key;
     93    for (int i = m_expressions->size() - 1; i >= 0; --i) {
    9194
    92     String previousSerializedExpression;
    93     for (size_t i = vector.size(); i; ) {
    94         --i;
     95        // if not all of the expressions is valid the media query must be ignored.
     96        if (!m_ignored)
     97            m_ignored = !m_expressions->at(i)->isValid();
    9598
    96         // If any expression is invalid, the entire media query must be ignored.
    97         m_ignored = m_ignored || !vector[i]->isValid();
    98 
    99         // Remove duplicate expressions.
    100         String serializedExpression = vector[i]->serialize();
    101         if (serializedExpression == previousSerializedExpression)
    102             vector.remove(i);
    103         previousSerializedExpression = serializedExpression;
     99        if (m_expressions->at(i)->serialize() == key)
     100            m_expressions->remove(i);
     101        else
     102            key = m_expressions->at(i)->serialize();
    104103    }
    105104}
    … …  
    110109    , m_expressions(adoptPtr(new Vector<OwnPtr<MediaQueryExp> >(o.m_expressions->size())))
    111110    , m_ignored(o.m_ignored)
    112     , m_serializedQuery(o.m_serializedQuery)
     111    , m_serializationCache(o.m_serializationCache)
    113112{
    114113    for (unsigned i = 0; i < m_expressions->size(); ++i)
    115114        (*m_expressions)[i] = o.m_expressions->at(i)->copy();
    116 }
    117 
    118 PassOwnPtr<MediaQuery> MediaQuery::copy() const
    119 {
    120     return adoptPtr(new MediaQuery(*this));
    121115}
    122116
    … …  
    125119}
    126120
     121// http://dev.w3.org/csswg/cssom/#compare-media-queries
    127122bool MediaQuery::operator==(const MediaQuery& other) const
    128123{
    … …  
    130125}
    131126
    132 const String& MediaQuery::cssText() const
     127// http://dev.w3.org/csswg/cssom/#serialize-a-list-of-media-queries
     128String MediaQuery::cssText() const
    133129{
    134     if (m_serializedQuery.isNull())
    135         const_cast<MediaQuery*>(this)->m_serializedQuery = serialize();
    136     return m_serializedQuery;
     130    if (m_serializationCache.isNull())
     131        const_cast<MediaQuery*>(this)->m_serializationCache = serialize();
     132
     133    return m_serializationCache;
    137134}
    138135
    139 } // namespace WebCore
     136} //namespace

  • trunk/Source/WebCore/css/MediaQuery.h

    r118650 r118659  
    3131
    3232#include "PlatformString.h"
     33#include <wtf/PassOwnPtr.h>
     34#include <wtf/Vector.h>
     35#include <wtf/text/StringHash.h>
    3336
    3437namespace WebCore {
    35 
    3638class MediaQueryExp;
    3739
    … …  
    3941    WTF_MAKE_FAST_ALLOCATED;
    4042public:
    41     enum Restrictor { Only, Not, None };
     43    enum Restrictor {
     44        Only, Not, None
     45    };
    4246
    4347    typedef Vector<OwnPtr<MediaQueryExp> > ExpressionVector;
    4448
    45     MediaQuery(Restrictor, const String& mediaType, PassOwnPtr<ExpressionVector>);
     49    MediaQuery(Restrictor, const String& mediaType, PassOwnPtr<ExpressionVector> exprs);
    4650    ~MediaQuery();
    4751
    48     bool operator==(const MediaQuery&) const;
    49 
    5052    Restrictor restrictor() const { return m_restrictor; }
    51     const ExpressionVector& expressions() const { return *m_expressions; }
    52     const String& mediaType() const { return m_mediaType; }
    53     const String& cssText() const;
     53    const Vector<OwnPtr<MediaQueryExp> >* expressions() const { return m_expressions.get(); }
     54    String mediaType() const { return m_mediaType; }
     55    bool operator==(const MediaQuery& other) const;
     56    String cssText() const;
    5457    bool ignored() const { return m_ignored; }
    5558
    56     PassOwnPtr<MediaQuery> copy() const;
     59    PassOwnPtr<MediaQuery> copy() const { return adoptPtr(new MediaQuery(*this)); }
    5760
    58 private:
     61 private:
    5962    MediaQuery(const MediaQuery&);
    60     void operator=(const MediaQuery&);
    61    
    62     String serialize() const;
    6363
    6464    Restrictor m_restrictor;
    … …  
    6666    OwnPtr<ExpressionVector> m_expressions;
    6767    bool m_ignored;
    68     String m_serializedQuery;
     68    String m_serializationCache;
     69
     70    String serialize() const;
    6971};
    7072

  • trunk/Source/WebCore/css/MediaQueryEvaluator.cpp

    r118650 r118659  
    5959enum MediaFeaturePrefix { MinPrefix, MaxPrefix, NoPrefix };
    6060
    61 typedef bool (*MediaFeatureEvaluationFunction)(CSSValue*, RenderStyle*, Frame*, MediaFeaturePrefix);
    62 typedef HashMap<AtomicStringImpl*, MediaFeatureEvaluationFunction> FunctionMap;
    63 
    64 // FIXME: color-index, min-color-index, and max-color-index are not implemented.
    65 // To implement them we'd have to add information about indexed color to the WebCore platform;
    66 // most modern platforms don't make use of indexed color, so it's not clear this is worthwhile.
    67 
    68 // FIXME: scan is not implemented: This media feature describes the scanning process of
    69 // TV output devices. To implement this we'd have to add information to the WebCore platform.
    70 
    71 // FIXME: resolution, min-resolution, max-resolution are not implemented: At the time this
    72 // was originally written the author said the CSS parser "didn't seem to support CSS_DIMENSION".
    73 
    74 MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, bool mediaFeatureResult)
     61typedef bool (*EvalFunc)(CSSValue*, RenderStyle*, Frame*, MediaFeaturePrefix);
     62typedef HashMap<AtomicStringImpl*, EvalFunc> FunctionMap;
     63static FunctionMap* gFunctionMap;
     64
     65/*
     66 * FIXME: following media features are not implemented: color_index, scan, resolution
     67 *
     68 * color_index, min-color-index, max_color_index: It's unknown how to retrieve
     69 * the information if the display mode is indexed
     70 * scan: The "scan" media feature describes the scanning process of
     71 * tv output devices. It's unknown how to retrieve this information from
     72 * the platform
     73 * resolution, min-resolution, max-resolution: css parser doesn't seem to
     74 * support CSS_DIMENSION
     75 */
     76
     77MediaQueryEvaluator::MediaQueryEvaluator(bool mediaFeatureResult)
     78    : m_frame(0)
     79    , m_style(0)
     80    , m_expResult(mediaFeatureResult)
     81{
     82}
     83
     84MediaQueryEvaluator:: MediaQueryEvaluator(const String& acceptedMediaType, bool mediaFeatureResult)
    7585    : m_mediaType(acceptedMediaType)
    7686    , m_frame(0)
    7787    , m_style(0)
    78     , m_mediaFeatureResult(mediaFeatureResult)
    79 {
    80 }
    81 
    82 MediaQueryEvaluator::MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult)
     88    , m_expResult(mediaFeatureResult)
     89{
     90}
     91
     92MediaQueryEvaluator:: MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult)
    8393    : m_mediaType(acceptedMediaType)
    8494    , m_frame(0)
    8595    , m_style(0)
    86     , m_mediaFeatureResult(mediaFeatureResult)
    87 {
    88 }
    89 
    90 MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, Frame* frame, RenderStyle* style)
     96    , m_expResult(mediaFeatureResult)
     97{
     98}
     99
     100MediaQueryEvaluator:: MediaQueryEvaluator(const String& acceptedMediaType, Frame* frame, RenderStyle* style)
    91101    : m_mediaType(acceptedMediaType)
    92102    , m_frame(frame)
    93103    , m_style(style)
    94     , m_mediaFeatureResult(false) // Ignored if both m_frame and m_style are non-null.
     104    , m_expResult(false) // doesn't matter when we have m_frame and m_style
    95105{
    96106}
    … …  
    127137
    128138    const Vector<OwnPtr<MediaQuery> >& queries = querySet->queryVector();
    129 
    130     bool result = true;
    131 
    132     // Iterate over queries and stop if any of them eval to true ("or" semantics).
    133     for (size_t i = 0; i < queries.size(); ++i) {
    134         const MediaQuery& query = *queries[i];
    135 
    136         result = false;
    137 
    138         if (query.ignored())
     139    if (!queries.size())
     140        return true; // empty query list evaluates to true
     141
     142    // iterate over queries, stop if any of them eval to true (OR semantics)
     143    bool result = false;
     144    for (size_t i = 0; i < queries.size() && !result; ++i) {
     145        MediaQuery* query = queries[i].get();
     146
     147        if (query->ignored())
    139148            continue;
    140149
    141         if (mediaTypeMatch(query.mediaType())) {
    142             const Vector<OwnPtr<MediaQueryExp> >& expressions = query.expressions();
     150        if (mediaTypeMatch(query->mediaType())) {
     151            const Vector<OwnPtr<MediaQueryExp> >* exps = query->expressions();
    143152            // iterate through expressions, stop if any of them eval to false
    144153            // (AND semantics)
    145154            size_t j = 0;
    146             for (; j < expressions.size(); ++j) {
    147                 result = eval(*expressions[j]);
    148                 if (styleResolver && expressions[j]->isViewportDependent())
    149                     styleResolver->addViewportDependentMediaQueryResult(*expressions[j], result);
    150                 if (!result)
     155            for (; j < exps->size(); ++j) {
     156                bool exprResult = eval(exps->at(j).get());
     157                if (styleResolver && exps->at(j)->isViewportDependent())
     158                    styleResolver->addViewportDependentMediaQueryResult(exps->at(j).get(), exprResult);
     159                if (!exprResult)
    151160                    break;
    152161            }
    153         }
    154 
    155         result = applyRestrictor(query.restrictor(), result);
    156         if (result)
    157             break;
     162
     163            // assume true if we are at the end of the list,
     164            // otherwise assume false
     165            result = applyRestrictor(query->restrictor(), exps->size() == j);
     166        } else
     167            result = applyRestrictor(query->restrictor(), false);
    158168    }
    159169
    … …  
    254264        int v = 0;
    255265        if (parseAspectRatio(value, h, v))
    256             return v && compareValue(width * v, height * h, op);
     266            return v != 0 && compareValue(width * v, height * h, op);
    257267        return false;
    258268    }
    … …  
    270280        int v = 0;
    271281        if (parseAspectRatio(value, h, v))
    272             return v && compareValue(static_cast<int>(sg.width()) * v, static_cast<int>(sg.height()) * h, op);
     282            return v != 0  && compareValue(static_cast<int>(sg.width()) * v, static_cast<int>(sg.height()) * h, op);
    273283        return false;
    274284    }
    … …  
    494504static bool transform_3dMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
    495505{
     506    bool returnValueIfNoParameter;
     507    int have3dRendering;
     508
     509#if ENABLE(3D_RENDERING)
    496510    bool threeDEnabled = false;
    497 #if ENABLE(3D_RENDERING) && USE(ACCELERATED_COMPOSITING)
     511#if USE(ACCELERATED_COMPOSITING)
    498512    if (RenderView* view = frame->contentRenderer())
    499513        threeDEnabled = view->compositor()->canRender3DTransforms();
     514#endif
     515
     516    returnValueIfNoParameter = threeDEnabled;
     517    have3dRendering = threeDEnabled ? 1 : 0;
    500518#else
    501519    UNUSED_PARAM(frame);
     520    returnValueIfNoParameter = false;
     521    have3dRendering = 0;
    502522#endif
     523
    503524    if (value) {
    504525        float number;
    505         return numberValue(value, number) && compareValue(static_cast<int>(threeDEnabled), static_cast<int>(number), op);
    506     }
    507     return threeDEnabled;
     526        return numberValue(value, number) && compareValue(have3dRendering, static_cast<int>(number), op);
     527    }
     528    return returnValueIfNoParameter;
    508529}
    509530
    510531static bool view_modeMediaFeatureEval(CSSValue* value, RenderStyle*, Frame* frame, MediaFeaturePrefix op)
    511532{
    512     ASSERT_UNUSED(op, op == NoPrefix);
     533    UNUSED_PARAM(op);
    513534    if (!value)
    514535        return true;
    … …  
    516537}
    517538
    518 static FunctionMap* createFunctionMap()
    519 {
    520     FunctionMap* functionMap = new FunctionMap;
     539static void createFunctionMap()
     540{
     541    // Create the table.
     542    gFunctionMap = new FunctionMap;
    521543#define ADD_TO_FUNCTIONMAP(name, str)  \
    522     functionMap->set(name##MediaFeature.impl(), name##MediaFeatureEval);
     544    gFunctionMap->set(name##MediaFeature.impl(), name##MediaFeatureEval);
    523545    CSS_MEDIAQUERY_NAMES_FOR_EACH_MEDIAFEATURE(ADD_TO_FUNCTIONMAP);
    524546#undef ADD_TO_FUNCTIONMAP
    525     return functionMap;
    526 }
    527 
    528 bool MediaQueryEvaluator::eval(const MediaQueryExp& expression) const
     547}
     548
     549bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const
    529550{
    530551    if (!m_frame || !m_style)
    531         return m_mediaFeatureResult;
    532 
    533     if (!expression.isValid())
     552        return m_expResult;
     553
     554    if (!expr->isValid())
    534555        return false;
    535556
    536     static FunctionMap* functionMap = createFunctionMap();
    537     MediaFeatureEvaluationFunction function = functionMap->get(expression.mediaFeature().impl());
    538 
    539     // Start with no prefix: Some trampoline functions add the prefix and call other media feature functions.
    540     return function && function(expression.value(), m_style.get(), m_frame, NoPrefix);
     557    if (!gFunctionMap)
     558        createFunctionMap();
     559
     560    // call the media feature evaluation function. Assume no prefix
     561    // and let trampoline functions override the prefix if prefix is
     562    // used
     563    EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl());
     564    if (func)
     565        return func(expr->value(), m_style.get(), m_frame, NoPrefix);
     566
     567    return false;
    541568}
    542569

  • trunk/Source/WebCore/css/MediaQueryEvaluator.h

    r118650 r118659  
    3232
    3333namespace WebCore {
    34 
    3534class Frame;
    3635class MediaQueryExp;
    … …  
    3938class StyleResolver;
    4039
    41 // Class that evaluates CSS media queries as defined in CSS3 Module "Media Queries".
    42 //
    43 // Special constructors are supplied so that simple media queries can be
    44 // evaluated without knowledge of device characteristics. This is used, for example,
    45 // when parsing user agent stylesheets. The boolean parameter to the constructor is used
    46 // if the device characteristics are not known. This can be used to prune loading
    47 // of stylesheets to remove those that definitely won't match.
    48 
     40/**
     41 * Class that evaluates css media queries as defined in
     42 * CSS3 Module "Media Queries" (http://www.w3.org/TR/css3-mediaqueries/)
     43 * Special constructors are needed, if simple media queries are to be
     44 * evaluated without knowledge of the medium features. This can happen
     45 * for example when parsing UA stylesheets, if evaluation is done
     46 * right after parsing.
     47 *
     48 * the boolean parameter is used to approximate results of evaluation, if
     49 * the device characteristics are not known. This can be used to prune the loading
     50 * of stylesheets to only those which are probable to match.
     51 */
    4952class MediaQueryEvaluator {
    5053     WTF_MAKE_NONCOPYABLE(MediaQueryEvaluator); WTF_MAKE_FAST_ALLOCATED;
    5154public:
    52     // Creates evaluator which evaluates only simple media queries.
    53     // Evaluator returns true for acceptedMediaType and uses mediaFeatureResult for any media features.
     55    /** Creates evaluator which evaluates only simple media queries
     56     *  Evaluator returns true for "all", and returns value of \mediaFeatureResult
     57     *  for any media features
     58     */
     59    MediaQueryEvaluator(bool mediaFeatureResult = false);
     60
     61    /** Creates evaluator which evaluates only simple media queries
     62     *  Evaluator  returns true for acceptedMediaType and returns value of \mediafeatureResult
     63     *  for any media features
     64     */
    5465    MediaQueryEvaluator(const String& acceptedMediaType, bool mediaFeatureResult = false);
    5566    MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult = false);
    5667
    57     // Creates evaluator which evaluates full media queries.
     68    /** Creates evaluator which evaluates full media queries
     69     */
    5870    MediaQueryEvaluator(const String& acceptedMediaType, Frame*, RenderStyle*);
    5971
    … …  
    6375    bool mediaTypeMatchSpecific(const char* mediaTypeToMatch) const;
    6476
    65     // Evaluates a list of media queries.
     77    /** Evaluates a list of media queries */
    6678    bool eval(const MediaQuerySet*, StyleResolver* = 0) const;
    6779
    68     // Evaluates media query subexpression, i.e. "and (media-feature: value)" part.
    69     bool eval(const MediaQueryExp&) const;
     80    /** Evaluates media query subexpression, ie "and (media-feature: value)" part */
     81    bool eval(const MediaQueryExp*) const;
    7082
    7183private:
    … …  
    7385    Frame* m_frame; // not owned
    7486    RefPtr<RenderStyle> m_style;
    75     bool m_mediaFeatureResult;
     87    bool m_expResult;
    7688};
    7789
    78 } // namespace WebCore
    79 
     90} // namespace
    8091#endif

  • trunk/Source/WebCore/css/StyleResolver.cpp

    r118650 r118659  
    7878#include "MediaList.h"
    7979#include "MediaQueryEvaluator.h"
    80 #include "MediaQueryExp.h"
    8180#include "NodeRenderStyle.h"
    8281#include "Page.h"
    … …  
    161160
    162161using namespace HTMLNames;
    163 
    164 struct MediaQueryResult {
    165     MediaQueryResult(const MediaQueryExp& expression, bool result)
    166         : expression(expression)
    167         , result(result)
    168     {
    169     }
    170 
    171     MediaQueryExp expression;
    172     bool result;
    173 };
    174162
    175163#define HANDLE_INHERIT(prop, Prop) \
    … …  
    51415129}
    51425130
    5143 void StyleResolver::addViewportDependentMediaQueryResult(const MediaQueryExp& expression, bool result)
    5144 {
    5145     m_viewportDependentMediaQueryResults.append(MediaQueryResult(expression, result));
     5131void StyleResolver::addViewportDependentMediaQueryResult(const MediaQueryExp* expr, bool result)
     5132{
     5133    m_viewportDependentMediaQueryResults.append(adoptPtr(new MediaQueryResult(*expr, result)));
    51465134}
    51475135
    51485136bool StyleResolver::affectedByViewportChange() const
    51495137{
    5150     unsigned size = m_viewportDependentMediaQueryResults.size();
    5151     for (unsigned i = 0; i < size; i++) {
    5152         if (m_medium->eval(m_viewportDependentMediaQueryResults[i].expression) != m_viewportDependentMediaQueryResults[i].result)
     5138    unsigned s = m_viewportDependentMediaQueryResults.size();
     5139    for (unsigned i = 0; i < s; i++) {
     5140        if (m_medium->eval(&m_viewportDependentMediaQueryResults[i]->m_expression) != m_viewportDependentMediaQueryResults[i]->m_result)
    51535141            return true;
    51545142    }

  • trunk/Source/WebCore/css/StyleResolver.h

    r118650 r118659  
    2323#define StyleResolver_h
    2424
     25#include "CSSRule.h"
     26#include "CSSValueList.h"
    2527#include "LinkHash.h"
     28#include "MediaQueryExp.h"
    2629#include "RenderStyle.h"
    2730#include "SelectorChecker.h"
     31#include <wtf/HashMap.h>
     32#include <wtf/HashSet.h>
     33#include <wtf/RefPtr.h>
     34#include <wtf/Vector.h>
     35#include <wtf/text/StringHash.h>
    2836
    2937namespace WebCore {
    3038
     39enum ESmartMinimumForFontSize { DoNotUseSmartMinimumForFontSize, UseSmartMinimumForFontFize };
     40
    3141class CSSFontSelector;
     42class CSSPageRule;
     43class CSSPrimitiveValue;
     44class CSSProperty;
     45class CSSRuleList;
     46class CSSFontFace;
     47class CSSFontFaceRule;
    3248class CSSImageGeneratorValue;
    3349class CSSImageSetValue;
    3450class CSSImageValue;
    35 class CSSRuleList;
     51class CSSSelector;
    3652class CSSStyleRule;
    3753class CSSStyleSheet;
     54class CSSValue;
    3855class ContainerNode;
    3956class CustomFilterOperation;
    … …  
    4158class Document;
    4259class Element;
     60class Frame;
     61class FrameView;
     62class KURL;
    4363class KeyframeList;
    4464class KeyframeValue;
    4565class MediaQueryEvaluator;
    46 class MediaQueryExp;
    4766class Node;
    4867class RenderRegion;
    4968class RuleData;
    5069class RuleSet;
     70class Settings;
    5171class StaticCSSRuleList;
    5272class StyleBuilder;
    … …  
    5878class StyleRuleKeyframes;
    5979class StyleRulePage;
     80class StyleRuleRegion;
    6081class StyleShader;
     82class StyleSheet;
    6183class StyleSheetContents;
     84class StyleSheetList;
    6285class StyledElement;
    6386class WebKitCSSFilterValue;
    6487class WebKitCSSShaderValue;
    6588
    66 struct MediaQueryResult;
    67 
    68 enum ESmartMinimumForFontSize { DoNotUseSmartMinimumForFontSize, UseSmartMinimumForFontFize };
    69    
    7089#if ENABLE(CSS_SHADERS)
    7190typedef Vector<RefPtr<CustomFilterParameter> > CustomFilterParameterList;
    7291#endif
     92
     93class MediaQueryResult {
     94    WTF_MAKE_NONCOPYABLE(MediaQueryResult); WTF_MAKE_FAST_ALLOCATED;
     95public:
     96    MediaQueryResult(const MediaQueryExp& expr, bool result)
     97        : m_expression(expr)
     98        , m_result(result)
     99    {
     100    }
     101
     102    MediaQueryExp m_expression;
     103    bool m_result;
     104};
    73105
    74106enum StyleSharingBehavior {
    … …  
    194226    CSSFontSelector* fontSelector() const { return m_fontSelector.get(); }
    195227
    196     void addViewportDependentMediaQueryResult(const MediaQueryExp&, bool result);
     228    void addViewportDependentMediaQueryResult(const MediaQueryExp*, bool result);
    197229
    198230    bool affectedByViewportChange() const;
    … …  
    465497
    466498    RefPtr<CSSFontSelector> m_fontSelector;
    467     Vector<MediaQueryResult> m_viewportDependentMediaQueryResults;
     499    Vector<OwnPtr<MediaQueryResult> > m_viewportDependentMediaQueryResults;
    468500
    469501    bool m_applyPropertyToRegularStyle;
Note: See TracChangeset for help on using the changeset viewer.