/*

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)

 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>

 * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>

 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 *

 * 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 "config.h"

#include "CSSStyleSelector.h"

#include "Attribute.h"

#include "CSSBorderImageValue.h"

#include "CSSCursorImageValue.h"

#include "CSSFontFaceRule.h"

#include "CSSImportRule.h"

#include "CSSMediaRule.h"

#include "CSSPageRule.h"

#include "CSSParser.h"

#include "CSSPrimitiveValueMappings.h"

#include "CSSPropertyNames.h"

#include "CSSReflectValue.h"

#include "CSSRuleList.h"

#include "CSSSelector.h"

#include "CSSSelectorList.h"

#include "CSSStyleRule.h"

#include "CSSStyleSheet.h"

#include "CSSTimingFunctionValue.h"

#include "CSSValueList.h"

#include "CSSVariableDependentValue.h"

#include "CSSVariablesDeclaration.h"

#include "CSSVariablesRule.h"

#include "CachedImage.h"

#include "Counter.h"

#include "CounterContent.h"

#include "FocusController.h"

#include "FontFamilyValue.h"

#include "FontValue.h"

#include "Frame.h"

#include "FrameView.h"

#include "HTMLDocument.h"

#include "HTMLElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HTMLTextAreaElement.h"

#include "KeyframeList.h"

#include "LinkHash.h"

#include "Matrix3DTransformOperation.h"

#include "MatrixTransformOperation.h"

#include "MediaList.h"

#include "MediaQueryEvaluator.h"

#include "NodeRenderStyle.h"

#include "Page.h"

#include "PageGroup.h"

#include "Pair.h"

#include "PerspectiveTransformOperation.h"

#include "Rect.h"

#include "RenderScrollbar.h"

#include "RenderScrollbarTheme.h"

#include "RenderStyleConstants.h"

#include "RenderTheme.h"

#include "RotateTransformOperation.h"

#include "ScaleTransformOperation.h"

#include "SelectionController.h"

#include "Settings.h"

#include "ShadowValue.h"

#include "SkewTransformOperation.h"

#include "StyleCachedImage.h"

#include "StyleGeneratedImage.h"

#include "StyleSheetList.h"

#include "Text.h"

#include "TransformationMatrix.h"

#include "TranslateTransformOperation.h"

#include "UserAgentStyleSheets.h"

#include "WebKitCSSKeyframeRule.h"

#include "WebKitCSSKeyframesRule.h"

#include "WebKitCSSTransformValue.h"

#include "XMLNames.h"

#include "loader.h"

#include <wtf/StdLibExtras.h>

#include <wtf/Vector.h>

#if ENABLE(DASHBOARD_SUPPORT)

#include "DashboardRegion.h"

#endif

#if ENABLE(SVG)

#include "XLinkNames.h"

#include "SVGNames.h"

#endif

#if ENABLE(WML)

#include "WMLNames.h"

#endif

#if PLATFORM(QT)

#include <qwebhistoryinterface.h>

#endif

using namespace std;

namespace WebCore {

using namespace HTMLNames;

// #define STYLE_SHARING_STATS 1

#define HANDLE_INHERIT(prop, Prop) \

if (isInherit) { \

    m_style->set##Prop(m_parentStyle->prop()); \

    return; \

}

#define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \

HANDLE_INHERIT(prop, Prop) \

if (isInitial) { \

    m_style->set##Prop(RenderStyle::initial##Prop()); \

    return; \

}

#define HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \

HANDLE_INHERIT(prop, Prop) \

if (isInitial) { \

    m_style->set##Prop(RenderStyle::initial##Value());\

    return;\

}

#define HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(prop, Prop) \

HANDLE_INHERIT_AND_INITIAL(prop, Prop) \

if (primitiveValue) \

    m_style->set##Prop(*primitiveValue);

#define HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE_WITH_VALUE(prop, Prop, Value) \

HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \

if (primitiveValue) \

    m_style->set##Prop(*primitiveValue);

#define HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(layerType, LayerType, prop, Prop) \

if (isInherit) { \

    FillLayer* currChild = m_style->access##LayerType##Layers(); \

    FillLayer* prevChild = 0; \

    const FillLayer* currParent = m_parentStyle->layerType##Layers(); \

    while (currParent && currParent->is##Prop##Set()) { \

        if (!currChild) { \

            /* Need to make a new layer.*/ \

            currChild = new FillLayer(LayerType##FillLayer); \

            prevChild->setNext(currChild); \

        } \

        currChild->set##Prop(currParent->prop()); \

        prevChild = currChild; \

        currChild = prevChild->next(); \

        currParent = currParent->next(); \

    } \

    \

    while (currChild) { \

        /* Reset any remaining layers to not have the property set. */ \

        currChild->clear##Prop(); \

        currChild = currChild->next(); \

    } \

} else if (isInitial) { \

    FillLayer* currChild = m_style->access##LayerType##Layers(); \

    currChild->set##Prop(FillLayer::initialFill##Prop(LayerType##FillLayer)); \

    for (currChild = currChild->next(); currChild; currChild = currChild->next()) \

        currChild->clear##Prop(); \

}

#define HANDLE_FILL_LAYER_VALUE(layerType, LayerType, prop, Prop, value) { \

HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(layerType, LayerType, prop, Prop) \

if (isInherit || isInitial) \

    return; \

FillLayer* currChild = m_style->access##LayerType##Layers(); \

FillLayer* prevChild = 0; \

if (value->isValueList()) { \

    /* Walk each value and put it into a layer, creating new layers as needed. */ \

    CSSValueList* valueList = static_cast<CSSValueList*>(value); \

    for (unsigned int i = 0; i < valueList->length(); i++) { \

        if (!currChild) { \

            /* Need to make a new layer to hold this value */ \

            currChild = new FillLayer(LayerType##FillLayer); \

            prevChild->setNext(currChild); \

        } \

        mapFill##Prop(currChild, valueList->itemWithoutBoundsCheck(i)); \

        prevChild = currChild; \

        currChild = currChild->next(); \

    } \

} else { \

    mapFill##Prop(currChild, value); \

    currChild = currChild->next(); \

} \

while (currChild) { \

    /* Reset all remaining layers to not have the property set. */ \

    currChild->clear##Prop(); \

    currChild = currChild->next(); \

} }

#define HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \

HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(background, Background, prop, Prop)

#define HANDLE_BACKGROUND_VALUE(prop, Prop, value) \

HANDLE_FILL_LAYER_VALUE(background, Background, prop, Prop, value)

#define HANDLE_MASK_INHERIT_AND_INITIAL(prop, Prop) \

HANDLE_FILL_LAYER_INHERIT_AND_INITIAL(mask, Mask, prop, Prop)

#define HANDLE_MASK_VALUE(prop, Prop, value) \

HANDLE_FILL_LAYER_VALUE(mask, Mask, prop, Prop, value)

#define HANDLE_ANIMATION_INHERIT_AND_INITIAL(prop, Prop) \

if (isInherit) { \

    AnimationList* list = m_style->accessAnimations(); \

    const AnimationList* parentList = m_parentStyle->animations(); \

    size_t i = 0, parentSize = parentList ? parentList->size() : 0; \

    for ( ; i < parentSize && parentList->animation(i)->is##Prop##Set(); ++i) { \

        if (list->size() <= i) \

            list->append(Animation::create()); \

        list->animation(i)->set##Prop(parentList->animation(i)->prop()); \

    } \

    \

    /* Reset any remaining animations to not have the property set. */ \

    for ( ; i < list->size(); ++i) \

        list->animation(i)->clear##Prop(); \

} else if (isInitial) { \

    AnimationList* list = m_style->accessAnimations(); \

    if (list->isEmpty()) \

        list->append(Animation::create()); \

    list->animation(0)->set##Prop(Animation::initialAnimation##Prop()); \

    for (size_t i = 1; i < list->size(); ++i) \

        list->animation(0)->clear##Prop(); \

}

#define HANDLE_ANIMATION_VALUE(prop, Prop, value) { \

HANDLE_ANIMATION_INHERIT_AND_INITIAL(prop, Prop) \

if (isInherit || isInitial) \

    return; \

AnimationList* list = m_style->accessAnimations(); \

size_t childIndex = 0; \

if (value->isValueList()) { \

    /* Walk each value and put it into an animation, creating new animations as needed. */ \

    CSSValueList* valueList = static_cast<CSSValueList*>(value); \

    for (unsigned int i = 0; i < valueList->length(); i++) { \

        if (childIndex <= list->size()) \

            list->append(Animation::create()); \

        mapAnimation##Prop(list->animation(childIndex), valueList->itemWithoutBoundsCheck(i)); \

        ++childIndex; \

    } \

} else { \

    if (list->isEmpty()) \

        list->append(Animation::create()); \

    mapAnimation##Prop(list->animation(childIndex), value); \

    childIndex = 1; \

} \

for ( ; childIndex < list->size(); ++childIndex) { \

    /* Reset all remaining animations to not have the property set. */ \

    list->animation(childIndex)->clear##Prop(); \

} \

}

#define HANDLE_TRANSITION_INHERIT_AND_INITIAL(prop, Prop) \

if (isInherit) { \

    AnimationList* list = m_style->accessTransitions(); \

    const AnimationList* parentList = m_parentStyle->transitions(); \

    size_t i = 0, parentSize = parentList ? parentList->size() : 0; \

    for ( ; i < parentSize && parentList->animation(i)->is##Prop##Set(); ++i) { \

        if (list->size() <= i) \

            list->append(Animation::create()); \

        list->animation(i)->set##Prop(parentList->animation(i)->prop()); \

    } \

    \

    /* Reset any remaining transitions to not have the property set. */ \

    for ( ; i < list->size(); ++i) \

        list->animation(i)->clear##Prop(); \

} else if (isInitial) { \

    AnimationList* list = m_style->accessTransitions(); \

    if (list->isEmpty()) \

        list->append(Animation::create()); \

    list->animation(0)->set##Prop(Animation::initialAnimation##Prop()); \

    for (size_t i = 1; i < list->size(); ++i) \

        list->animation(0)->clear##Prop(); \

}

#define HANDLE_TRANSITION_VALUE(prop, Prop, value) { \

HANDLE_TRANSITION_INHERIT_AND_INITIAL(prop, Prop) \

if (isInherit || isInitial) \

    return; \

AnimationList* list = m_style->accessTransitions(); \

size_t childIndex = 0; \

if (value->isValueList()) { \

    /* Walk each value and put it into a transition, creating new animations as needed. */ \

    CSSValueList* valueList = static_cast<CSSValueList*>(value); \

    for (unsigned int i = 0; i < valueList->length(); i++) { \

        if (childIndex <= list->size()) \

            list->append(Animation::create()); \

        mapAnimation##Prop(list->animation(childIndex), valueList->itemWithoutBoundsCheck(i)); \

        ++childIndex; \

    } \

} else { \

    if (list->isEmpty()) \

        list->append(Animation::create()); \

    mapAnimation##Prop(list->animation(childIndex), value); \

    childIndex = 1; \

} \

for ( ; childIndex < list->size(); ++childIndex) { \

    /* Reset all remaining transitions to not have the property set. */ \

    list->animation(childIndex)->clear##Prop(); \

} \

}

#define HANDLE_INHERIT_COND(propID, prop, Prop) \

if (id == propID) { \

    m_style->set##Prop(m_parentStyle->prop()); \

    return; \

}

#define HANDLE_INHERIT_COND_WITH_BACKUP(propID, prop, propAlt, Prop) \

if (id == propID) { \

    if (m_parentStyle->prop().isValid()) \

        m_style->set##Prop(m_parentStyle->prop()); \

    else \

        m_style->set##Prop(m_parentStyle->propAlt()); \

    return; \

}

#define HANDLE_INITIAL_COND(propID, Prop) \

if (id == propID) { \

    m_style->set##Prop(RenderStyle::initial##Prop()); \

    return; \

}

#define HANDLE_INITIAL_COND_WITH_VALUE(propID, Prop, Value) \

if (id == propID) { \

    m_style->set##Prop(RenderStyle::initial##Value()); \

    return; \

}

class CSSRuleSet : public Noncopyable {

public:

    CSSRuleSet();

    ~CSSRuleSet();

    typedef HashMap<AtomicStringImpl*, CSSRuleDataList*> AtomRuleMap;

    void addRulesFromSheet(CSSStyleSheet*, const MediaQueryEvaluator&, CSSStyleSelector* = 0);

    void addStyleRule(StyleBase* item);

    void addRule(CSSStyleRule* rule, CSSSelector* sel);

    void addPageRule(CSSStyleRule* rule, CSSSelector* sel);

    void addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,

                      CSSStyleRule* rule, CSSSelector* sel);

    CSSRuleDataList* getIDRules(AtomicStringImpl* key) { return m_idRules.get(key); }

    CSSRuleDataList* getClassRules(AtomicStringImpl* key) { return m_classRules.get(key); }

    CSSRuleDataList* getTagRules(AtomicStringImpl* key) { return m_tagRules.get(key); }

    CSSRuleDataList* getUniversalRules() { return m_universalRules; }

    CSSRuleDataList* getPageRules() { return m_pageRules; }

public:

    AtomRuleMap m_idRules;

    AtomRuleMap m_classRules;

    AtomRuleMap m_tagRules;

    CSSRuleDataList* m_universalRules;

    CSSRuleDataList* m_pageRules;

    unsigned m_ruleCount;

    unsigned m_pageRuleCount;

};

static CSSRuleSet* defaultStyle;

static CSSRuleSet* defaultQuirksStyle;

static CSSRuleSet* defaultPrintStyle;

static CSSRuleSet* defaultViewSourceStyle;

static CSSStyleSheet* simpleDefaultStyleSheet;

RenderStyle* CSSStyleSelector::s_styleNotYetAvailable;

static void loadFullDefaultStyle();

static void loadSimpleDefaultStyle();

// FIXME: It would be nice to use some mechanism that guarantees this is in sync with the real UA stylesheet.

static const char* simpleUserAgentStyleSheet = "html,body,div{display:block}body{margin:8px}div:focus,span:focus{outline:auto 5px -webkit-focus-ring-color}a:-webkit-any-link{color:-webkit-link;text-decoration:underline}a:-webkit-any-link:active{color:-webkit-activelink}";

static bool elementCanUseSimpleDefaultStyle(Element* e)

{

    return e->hasTagName(htmlTag) || e->hasTagName(bodyTag) || e->hasTagName(divTag) || e->hasTagName(spanTag) || e->hasTagName(brTag) || e->hasTagName(aTag);

}

static const MediaQueryEvaluator& screenEval()

{

    DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));

    return staticScreenEval;

}

static const MediaQueryEvaluator& printEval()

{

    DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticPrintEval, ("print"));

    return staticPrintEval;

}

CSSStyleSelector::CSSStyleSelector(Document* doc, StyleSheetList* styleSheets, CSSStyleSheet* mappedElementSheet,

                                   CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets,

                                   bool strictParsing, bool matchAuthorAndUserStyles)

    : m_backgroundData(BackgroundFillLayer)

    , m_checker(doc, strictParsing)

    , m_element(0)

    , m_styledElement(0)

    , m_elementLinkState(NotInsideLink)

    , m_fontSelector(CSSFontSelector::create(doc))

{

    init();

    m_matchAuthorAndUserStyles = matchAuthorAndUserStyles;

    Element* root = doc->documentElement();

    if (!defaultStyle) {

        if (!root || elementCanUseSimpleDefaultStyle(root))

            loadSimpleDefaultStyle();

        else

            loadFullDefaultStyle();

    }

    m_userStyle = 0;

    // construct document root element default style. this is needed

    // to evaluate media queries that contain relative constraints, like "screen and (max-width: 10em)"

    // This is here instead of constructor, because when constructor is run,

    // document doesn't have documentElement

    // NOTE: this assumes that element that gets passed to styleForElement -call

    // is always from the document that owns the style selector

    FrameView* view = doc->view();

    if (view)

        m_medium = new MediaQueryEvaluator(view->mediaType());

    else

        m_medium = new MediaQueryEvaluator("all");

    if (root)

        m_rootDefaultStyle = styleForElement(root, 0, false, true); // don't ref, because the RenderStyle is allocated from global heap

    if (m_rootDefaultStyle && view) {

        delete m_medium;

        m_medium = new MediaQueryEvaluator(view->mediaType(), view->frame(), m_rootDefaultStyle.get());

    }

    // FIXME: This sucks! The user sheet is reparsed every time!

    if (pageUserSheet || pageGroupUserSheets) {

        m_userStyle = new CSSRuleSet();

        if (pageUserSheet)

            m_userStyle->addRulesFromSheet(pageUserSheet, *m_medium, this);

        if (pageGroupUserSheets) {

            unsigned length = pageGroupUserSheets->size();

            for (unsigned i = 0; i < length; i++)

                m_userStyle->addRulesFromSheet(pageGroupUserSheets->at(i).get(), *m_medium, this);

        }

    }

    // add stylesheets from document

    m_authorStyle = new CSSRuleSet();

    // Add rules from elements like SVG's <font-face>

    if (mappedElementSheet)

        m_authorStyle->addRulesFromSheet(mappedElementSheet, *m_medium, this);

    unsigned length = styleSheets->length();

    for (unsigned i = 0; i < length; i++) {

        StyleSheet* sheet = styleSheets->item(i);

        if (sheet->isCSSStyleSheet() && !sheet->disabled())

            m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(sheet), *m_medium, this);

    }

    if (doc->renderer() && doc->renderer()->style())

        doc->renderer()->style()->font().update(fontSelector());

}

// This is a simplified style setting function for keyframe styles

void CSSStyleSelector::addKeyframeStyle(PassRefPtr<WebKitCSSKeyframesRule> rule)

{

    AtomicString s(rule->name());

    m_keyframesRuleMap.add(s.impl(), rule);

}

void CSSStyleSelector::init()

{

    initElement(0);

    m_matchedDecls.clear();

    m_ruleList = 0;

    m_rootDefaultStyle = 0;

    m_medium = 0;

}

CSSStyleSelector::~CSSStyleSelector()

{

    m_fontSelector->clearDocument();

    delete m_medium;

    delete m_authorStyle;

    delete m_userStyle;

    deleteAllValues(m_viewportDependentMediaQueryResults);

    m_keyframesRuleMap.clear();

}

static CSSStyleSheet* parseUASheet(const String& str)

{

    CSSStyleSheet* sheet = CSSStyleSheet::create().releaseRef(); // leak the sheet on purpose

    sheet->parseString(str);

    return sheet;

}

static CSSStyleSheet* parseUASheet(const char* characters, unsigned size)

{

    return parseUASheet(String(characters, size));

}

static void loadFullDefaultStyle()

{

    if (simpleDefaultStyleSheet) {