1 /**

     2  * This file is part of the CSS implementation for KDE.

     3  *

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

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

     6  *           (C) 2006 Nicholas Shanks (webkit@nickshanks.com)

     7  * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.

     8  *

     9  * This library is free software; you can redistribute it and/or

    10  * modify it under the terms of the GNU Library General Public

    11  * License as published by the Free Software Foundation; either

    12  * version 2 of the License, or (at your option) any later version.

    13  *

    14  * This library is distributed in the hope that it will be useful,

    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17  * Library General Public License for more details.

    18  *

    19  * You should have received a copy of the GNU Library General Public License

    20  * along with this library; see the file COPYING.LIB.  If not, write to

    21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    22  * Boston, MA 02110-1301, USA.

    23  */

    24 

    25 #include "config.h"

    26 #include "CSSStyleSelector.h"

    27 

    28 #include "CSSBorderImageValue.h"

    29 #include "CSSCursorImageValue.h"

    30 #include "CSSImageValue.h"

    31 #include "CSSImportRule.h"

    32 #include "CSSMediaRule.h"

    33 #include "CSSProperty.h"

    34 #include "CSSPropertyNames.h"

    35 #include "CSSRuleList.h"

    36 #include "CSSSelector.h"

    37 #include "CSSStyleRule.h"

    38 #include "CSSStyleSheet.h"

    39 #include "CSSValueKeywords.h"

    40 #include "CSSValueList.h"

    41 #include "CachedImage.h"

    42 #include "Counter.h"

    43 #include "DashboardRegion.h"

    44 #include "FontFamilyValue.h"

    45 #include "FontValue.h"

    46 #include "Frame.h"

    47 #include "FrameView.h"

    48 #include "GlobalHistory.h"

    49 #include "HTMLDocument.h"

    50 #include "HTMLElement.h"

    51 #include "HTMLInputElement.h"

    52 #include "HTMLNames.h"

    53 #include "MediaList.h"

    54 #include "MediaQueryEvaluator.h"

    55 #include "Pair.h"

    56 #include "Rect.h"

    57 #include "RenderTheme.h"

    58 #include "Settings.h"

    59 #include "ShadowValue.h"

    60 #include "StyleSheetList.h"

    61 #include "UserAgentStyleSheets.h"

    62 #include "loader.h"

    63 

    64 #if ENABLE(SVG)

    65 #include "XLinkNames.h"

    66 #include "SVGNames.h"

    67 #endif

    68 

    69 #if PLATFORM(SYMBIAN)

    70 #include "Frame.h"

    71 #include "WebCoreFrameBridge.h"

    72 #endif

    73 

    74 

    75 using namespace std;

    76 

    77 namespace WebCore {

    78 

    79 using namespace HTMLNames;

    80 

    81 // #define STYLE_SHARING_STATS 1

    82 

    83 #define HANDLE_INHERIT(prop, Prop) \

    84 if (isInherit) { \

    85     style->set##Prop(parentStyle->prop()); \

    86     return; \

    87 }

    88 

    89 #define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \

    90 HANDLE_INHERIT(prop, Prop) \

    91 if (isInitial) { \

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

    93     return; \

    94 }

    95 

    96 #define HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \

    97 HANDLE_INHERIT(prop, Prop) \

    98 if (isInitial) { \

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

   100     return;\

   101 }

   102 

   103 #define HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \

   104 if (isInherit) { \

   105     BackgroundLayer* currChild = style->accessBackgroundLayers(); \

   106     BackgroundLayer* prevChild = 0; \

   107     const BackgroundLayer* currParent = parentStyle->backgroundLayers(); \

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

   109         if (!currChild) { \

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

   111             currChild = new BackgroundLayer(); \

   112             prevChild->setNext(currChild); \

   113         } \

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

   115         prevChild = currChild; \

   116         currChild = prevChild->next(); \

   117         currParent = currParent->next(); \

   118     } \

   119     \

   120     while (currChild) { \

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

   122         currChild->clear##Prop(); \

   123         currChild = currChild->next(); \

   124     } \

   125     return; \

   126 } \

   127 if (isInitial) { \

   128     BackgroundLayer* currChild = style->accessBackgroundLayers(); \

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

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

   131         currChild->clear##Prop(); \

   132     return; \

   133 }

   134 

   135 #define HANDLE_BACKGROUND_VALUE(prop, Prop, value) { \

   136 HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \

   137 if (!value->isPrimitiveValue() && !value->isValueList()) \

   138     return; \

   139 BackgroundLayer* currChild = style->accessBackgroundLayers(); \

   140 BackgroundLayer* prevChild = 0; \

   141 if (value->isPrimitiveValue()) { \

   142     map##Prop(currChild, value); \

   143     currChild = currChild->next(); \

   144 } \

   145 else { \

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

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

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

   149         if (!currChild) { \

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

   151             currChild = new BackgroundLayer(); \

   152             prevChild->setNext(currChild); \

   153         } \

   154         map##Prop(currChild, valueList->item(i)); \

   155         prevChild = currChild; \

   156         currChild = currChild->next(); \

   157     } \

   158 } \

   159 while (currChild) { \

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

   161     currChild->clear##Prop(); \

   162     currChild = currChild->next(); \

   163 } }

   164 

   165 #define HANDLE_INHERIT_COND(propID, prop, Prop) \

   166 if (id == propID) { \

   167     style->set##Prop(parentStyle->prop()); \

   168     return; \

   169 }

   170 

   171 #define HANDLE_INITIAL_COND(propID, Prop) \

   172 if (id == propID) { \

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

   174     return; \

   175 }

   176 

   177 #define HANDLE_INITIAL_COND_WITH_VALUE(propID, Prop, Value) \

   178 if (id == propID) { \

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

   180     return; \

   181 }

   182 

   183 class CSSRuleSet

   184 {

   185 public:

   186     CSSRuleSet();

   187     ~CSSRuleSet();

   188     

   189     typedef HashMap<AtomicStringImpl*, CSSRuleDataList*> AtomRuleMap;

   190     

   191     void addRulesFromSheet(CSSStyleSheet* sheet, MediaQueryEvaluator* medium);

   192     

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

   194     void addToRuleSet(AtomicStringImpl* key, AtomRuleMap& map,

   195                       CSSStyleRule* rule, CSSSelector* sel);

   196     

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

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

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

   200     CSSRuleDataList* getUniversalRules() { return m_universalRules; }

   201     

   202 public:

   203     AtomRuleMap m_idRules;

   204     AtomRuleMap m_classRules;

   205     AtomRuleMap m_tagRules;

   206     CSSRuleDataList* m_universalRules;

   207     

   208     unsigned m_ruleCount;

   209 };

   210 

   211 CSSRuleSet* CSSStyleSelector::defaultStyle = 0;

   212 CSSRuleSet* CSSStyleSelector::defaultQuirksStyle = 0;

   213 CSSRuleSet* CSSStyleSelector::defaultPrintStyle = 0;

   214 CSSRuleSet* CSSStyleSelector::defaultViewSourceStyle = 0;

   215 

   216 CSSStyleSheet* CSSStyleSelector::defaultSheet = 0;

   217 RenderStyle* CSSStyleSelector::styleNotYetAvailable = 0;

   218 CSSStyleSheet* CSSStyleSelector::quirksSheet = 0;

   219 CSSStyleSheet* CSSStyleSelector::viewSourceSheet = 0;

   220 

   221 #if ENABLE(SVG)

   222 CSSStyleSheet *CSSStyleSelector::svgSheet = 0;

   223 #endif

   224 

   225 static CSSStyleSelector::Encodedurl *currentEncodedURL = 0;

   226 static PseudoState pseudoState;

   227 

   228 CSSStyleSelector::CSSStyleSelector(Document* doc, const String& userStyleSheet, StyleSheetList *styleSheets, bool _strictParsing)

   229 {

   230     init();

   231     

   232     m_document = doc;

   233 

   234     strictParsing = _strictParsing;

   235     if (!defaultStyle)

   236         loadDefaultStyle();

   237 

   238     m_userStyle = 0;

   239 

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

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

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

   243     // document doesn't have documentElement

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

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

   246     FrameView* view = m_document->view();

   247     if (view)

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

   249     else

   250         m_medium = new MediaQueryEvaluator("all");

   251 

   252     Element* root = doc->documentElement();

   253 

   254     if (root)

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

   256 

   257     if (m_rootDefaultStyle && view) {

   258         delete m_medium;

   259         m_medium = new MediaQueryEvaluator(view->mediaType(), view->frame()->page(), m_rootDefaultStyle);

   260     }

   261 

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

   263     if (!userStyleSheet.isEmpty()) {

   264         m_userSheet = new CSSStyleSheet(doc);

   265         m_userSheet->parseString(userStyleSheet, strictParsing);

   266 

   267         m_userStyle = new CSSRuleSet();

   268         m_userStyle->addRulesFromSheet(m_userSheet.get(), m_medium);

   269     }

   270 

   271     // add stylesheets from document

   272     m_authorStyle = new CSSRuleSet();

   273 

   274     DeprecatedPtrListIterator<StyleSheet> it(styleSheets->styleSheets);

   275     for (; it.current(); ++it)

   276         if (it.current()->isCSSStyleSheet() && !it.current()->disabled())

   277             m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(it.current()), m_medium);

   278 

   279 }

   280 

   281 CSSStyleSelector::CSSStyleSelector(CSSStyleSheet *sheet)

   282 {

   283     init();

   284 

   285     if (!defaultStyle)

   286         loadDefaultStyle();

   287     FrameView *view = sheet->doc()->view();

   288 

   289     if (view)

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

   291     else

   292         m_medium = new MediaQueryEvaluator("all");

   293 

   294     Element* root = sheet->doc()->documentElement();

   295     if (root)

   296         m_rootDefaultStyle = styleForElement(root, 0, false, true);

   297 

   298     if (m_rootDefaultStyle && view) {

   299         delete m_medium;

   300         m_medium = new MediaQueryEvaluator(view->mediaType(), view->frame()->page(), m_rootDefaultStyle);

   301     }

   302 

   303     m_authorStyle = new CSSRuleSet();

   304     m_authorStyle->addRulesFromSheet(sheet, m_medium);

   305 }

   306 

   307 void CSSStyleSelector::init()

   308 {

   309     element = 0;

   310     m_matchedDecls.clear();

   311     m_ruleList = 0;

   312     m_collectRulesOnly = false;

   313     m_rootDefaultStyle = 0;

   314     m_medium = 0;

   315 }

   316 

   317 void CSSStyleSelector::setEncodedURL(const KURL& url)

   318 {

   319     KURL u = url;

   320 

   321     u.setQuery(DeprecatedString::null);

   322     u.setRef(DeprecatedString::null);

   323     encodedurl.file = u.url();

   324     int pos = encodedurl.file.findRev('/');

   325     encodedurl.path = encodedurl.file;

   326     if (pos > 0) {

   327         encodedurl.path.truncate(pos);

   328         encodedurl.path += '/';

   329     }

   330     u.setPath(DeprecatedString::null);

   331     encodedurl.host = u.url();

   332 }

   333 

   334 CSSStyleSelector::~CSSStyleSelector()

   335 {

   336     delete m_medium;

   337     ::delete m_rootDefaultStyle;

   338 

   339     delete m_authorStyle;

   340     delete m_userStyle;

   341 }

   342 

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

   344 {

   345     CSSStyleSheet* const parent = 0;

   346     CSSStyleSheet* sheet = new CSSStyleSheet(parent);

   347     sheet->ref(); // leak the sheet on purpose since it will be stored in a global variable

   348     sheet->parseString(String(characters, size));

   349     return sheet;

   350 }

   351 

   352 template<typename T> CSSStyleSheet* parseUASheet(const T& array)

   353 {

   354     return parseUASheet((const char*)array, sizeof(array));

   355 

   356 }

   357 

   358 void CSSStyleSelector::loadDefaultStyle()

   359 {

   360     if (defaultStyle)

   361         return;

   362 

   363     defaultStyle = new CSSRuleSet;

   364     defaultPrintStyle = new CSSRuleSet;

   365     defaultQuirksStyle = new CSSRuleSet;

   366     defaultViewSourceStyle = new CSSRuleSet;

   367 

   368     MediaQueryEvaluator screenEval("screen");

   369     MediaQueryEvaluator printEval("print");

   370 

   371     // Strict-mode rules.

   372     defaultSheet = parseUASheet(html4UserAgentStyleSheet);

   373     defaultStyle->addRulesFromSheet(defaultSheet, &screenEval);

   374     defaultPrintStyle->addRulesFromSheet(defaultSheet, &printEval);

   375 

   376 #if ENABLE(SVG)

   377     // SVG rules.

   378     svgSheet = parseUASheet(svgUserAgentStyleSheet);

   379     defaultStyle->addRulesFromSheet(svgSheet, &screenEval);

   380     defaultPrintStyle->addRulesFromSheet(svgSheet, &printEval);

   381 #endif

   382 

   383     // Quirks-mode rules.

   384     quirksSheet = parseUASheet(quirksUserAgentStyleSheet);

   385     defaultQuirksStyle->addRulesFromSheet(quirksSheet, &screenEval);

   386     

   387     // View source rules.

   388     viewSourceSheet = parseUASheet(sourceUserAgentStyleSheet);

   389     defaultViewSourceStyle->addRulesFromSheet(viewSourceSheet, &screenEval);

   390 }

   391 

   392 void CSSStyleSelector::matchRules(CSSRuleSet* rules, int& firstRuleIndex, int& lastRuleIndex)

   393 {

   394     m_matchedRules.clear();

   395 

   396     if (!rules || !element)

   397         return;

   398     

   399     // We need to collect the rules for id, class, tag, and everything else into a buffer and

   400     // then sort the buffer.

   401     if (element->hasID())

   402         matchRulesForList(rules->getIDRules(element->getIDAttribute().impl()), firstRuleIndex, lastRuleIndex);

   403     if (element->hasClass()) {

   404         for (const AtomicStringList* singleClass = element->getClassList(); singleClass; singleClass = singleClass->next())

   405             matchRulesForList(rules->getClassRules(singleClass->string().impl()), firstRuleIndex, lastRuleIndex);

   406     }

   407     matchRulesForList(rules->getTagRules(element->localName().impl()), firstRuleIndex, lastRuleIndex);

   408     matchRulesForList(rules->getUniversalRules(), firstRuleIndex, lastRuleIndex);

   409     

   410     // If we didn't match any rules, we're done.

   411     if (m_matchedRules.isEmpty())

   412         return;

   413     

   414     // Sort the set of matched rules.

   415     sortMatchedRules(0, m_matchedRules.size());

   416     

   417     // Now transfer the set of matched rules over to our list of decls.

   418     if (!m_collectRulesOnly) {

   419         for (unsigned i = 0; i < m_matchedRules.size(); i++)

   420             addMatchedDeclaration(m_matchedRules[i]->rule()->declaration());

   421     } else {

   422         for (unsigned i = 0; i < m_matchedRules.size(); i++) {

   423             if (!m_ruleList)

   424                 m_ruleList = new CSSRuleList();

   425             m_ruleList->append(m_matchedRules[i]->rule());

   426         }

   427     }

   428 }

   429 

   430 void CSSStyleSelector::matchRulesForList(CSSRuleDataList* rules, int& firstRuleIndex, int& lastRuleIndex)

   431 {

   432     if (!rules)

   433         return;

   434 

   435     for (CSSRuleData* d = rules->first(); d; d = d->next()) {

   436         CSSStyleRule* rule = d->rule();

   437         const AtomicString& localName = element->localName();

   438         const AtomicString& selectorLocalName = d->selector()->m_tag.localName();

   439         if ((localName == selectorLocalName || selectorLocalName == starAtom) && checkSelector(d->selector(), element)) {

   440             // If the rule has no properties to apply, then ignore it.

   441             CSSMutableStyleDeclaration* decl = rule->declaration();

   442             if (!decl || !decl->length())

   443                 continue;

   444             

   445             // If we're matching normal rules, set a pseudo bit if 

   446             // we really just matched a pseudo-element.

   447             if (dynamicPseudo != RenderStyle::NOPSEUDO && pseudoStyle == RenderStyle::NOPSEUDO) {

   448                 if (m_collectRulesOnly)

   449                     return;

   450                 style->setHasPseudoStyle(dynamicPseudo);

   451             } else {

   452                 // Update our first/last rule indices in the matched rules array.

   453                 lastRuleIndex = m_matchedDecls.size() + m_matchedRules.size();

   454                 if (firstRuleIndex == -1)

   455                     firstRuleIndex = lastRuleIndex;

   456 

   457                 // Add this rule to our list of matched rules.

   458                 addMatchedRule(d);

   459             }

   460         }

   461     }

   462 }

   463 

   464 bool operator >(CSSRuleData& r1, CSSRuleData& r2)

   465 {

   466     int spec1 = r1.selector()->specificity();

   467     int spec2 = r2.selector()->specificity();

   468     return (spec1 == spec2) ? r1.position() > r2.position() : spec1 > spec2; 

   469 }

   470 bool operator <=(CSSRuleData& r1, CSSRuleData& r2)

   471 {

   472     return !(r1 > r2);

   473 }

   474 

   475 void CSSStyleSelector::sortMatchedRules(unsigned start, unsigned end)

   476 {

   477     if (start >= end || (end - start == 1))

   478         return; // Sanity check.

   479 

   480     if (end - start <= 6) {

   481         // Apply a bubble sort for smaller lists.

   482         for (unsigned i = end - 1; i > start; i--) {

   483             bool sorted = true;

   484             for (unsigned j = start; j < i; j++) {

   485                 CSSRuleData* elt = m_matchedRules[j];

   486                 CSSRuleData* elt2 = m_matchedRules[j + 1];

   487                 if (*elt > *elt2) {

   488                     sorted = false;

   489                     m_matchedRules[j] = elt2;

   490                     m_matchedRules[j + 1] = elt;

   491                 }

   492             }

   493             if (sorted)

   494                 return;

   495         }

   496         return;

   497     }

   498 

   499     // Peform a merge sort for larger lists.

   500     unsigned mid = (start + end) / 2;

   501     sortMatchedRules(start, mid);

   502     sortMatchedRules(mid, end);

   503     

   504     CSSRuleData* elt = m_matchedRules[mid - 1];

   505     CSSRuleData* elt2 = m_matchedRules[mid];

   506     

   507     // Handle the fast common case (of equal specificity).  The list may already

   508     // be completely sorted.

   509     if (*elt <= *elt2)

   510         return;

   511     

   512     // We have to merge sort.  Ensure our merge buffer is big enough to hold

   513     // all the items.

   514     Vector<CSSRuleData*> rulesMergeBuffer;

   515     rulesMergeBuffer.reserveCapacity(end - start); 

   516 

   517     unsigned i1 = start;

   518     unsigned i2 = mid;

   519     

   520     elt = m_matchedRules[i1];

   521     elt2 = m_matchedRules[i2];

   522     

   523     while (i1 < mid || i2 < end) {

   524         if (i1 < mid && (i2 == end || *elt <= *elt2)) {

   525             rulesMergeBuffer.append(elt);

   526             if (++i1 < mid)

   527                 elt = m_matchedRules[i1];

   528         } else {

   529             rulesMergeBuffer.append(elt2);

   530             if (++i2 < end)

   531                 elt2 = m_matchedRules[i2];

   532         }

   533     }

   534     

   535     for (unsigned i = start; i < end; i++)

   536         m_matchedRules[i] = rulesMergeBuffer[i - start];

   537 }

   538 

   539 void CSSStyleSelector::initElementAndPseudoState(Element* e)

   540 {

   541     element = e;

   542     if (element && element->isStyledElement())

   543         styledElement = static_cast<StyledElement*>(element);

   544     else

   545         styledElement = 0;

   546     currentEncodedURL = &encodedurl;

   547     pseudoState = PseudoUnknown;

   548 }

   549 

   550 void CSSStyleSelector::initForStyleResolve(Element* e, RenderStyle* defaultParent)

   551 {

   552     // set some variables we will need

   553     pseudoStyle = RenderStyle::NOPSEUDO;

   554 

   555     parentNode = e->parentNode();

   556 

   557 #if ENABLE(SVG)

   558     if (!parentNode && e->isSVGElement() && e->isShadowNode())

   559         parentNode = e->shadowParentNode();

   560 #endif

   561 

   562     if (defaultParent)

   563         parentStyle = defaultParent;

   564     else

   565         parentStyle = parentNode ? parentNode->renderStyle() : 0;

   566     isXMLDoc = !element->document()->isHTMLDocument();

   567 

   568     style = 0;

   569     

   570     m_matchedDecls.clear();

   571 

   572     m_ruleList = 0;

   573 

   574     fontDirty = false;

   575 }

   576 

   577 // modified version of the one in kurl.cpp

   578 static void cleanpath(DeprecatedString &path)

   579 {

   580     int pos;

   581     while ((pos = path.find("/../")) != -1) {

   582         int prev = 0;

   583         if (pos > 0)

   584             prev = path.findRev("/", pos -1);

   585         // don't remove the host, i.e. http://foo.org/../foo.html

   586         if (prev < 0 || (prev > 3 && path.findRev("://", prev-1) == prev-2))

   587             path.remove(pos, 3);

   588         else

   589             // matching directory found ?

   590             path.remove(prev, pos- prev + 3);

   591     }

   592     pos = 0;

   593     

   594     // Don't remove "//" from an anchor identifier. -rjw

   595     // Set refPos to -2 to mean "I haven't looked for the anchor yet".

   596     // We don't want to waste a function call on the search for the the anchor

   597     // in the vast majority of cases where there is no "//" in the path.

   598     int refPos = -2;

   599     while ((pos = path.find("//", pos)) != -1) {

   600         if (refPos == -2)

   601             refPos = path.find("#");

   602         if (refPos > 0 && pos >= refPos)

   603             break;

   604         

   605         if (pos == 0 || path[pos-1] != ':')

   606             path.remove(pos, 1);

   607         else

   608             pos += 2;

   609     }

   610     while ((pos = path.find("/./")) != -1)

   611         path.remove(pos, 2);

   612 }

   613 

   614 static void checkPseudoState(Element *e, bool checkVisited = true)

   615 {

   616     if (!e->isLink()) {

   617         pseudoState = PseudoNone;

   618         return;

   619     }

   620     

   621     AtomicString attr;

   622     if (e->isHTMLElement())

   623         attr = e->getAttribute(hrefAttr);

   624 #if ENABLE(SVG)

   625     else if (e->isSVGElement())

   626         attr = e->getAttribute(XLinkNames::hrefAttr);

   627 #endif

   628     if (attr.isNull()) {

   629         pseudoState = PseudoNone;

   630         return;

   631     }

   632     

   633     if (!checkVisited) {

   634         pseudoState = PseudoAnyLink;

   635         return;

   636     }

   637     

   638     DeprecatedConstString cu(reinterpret_cast<const DeprecatedChar*>(attr.characters()), attr.length());

   639     DeprecatedString u = cu.string();

   640     if (!u.contains("://")) {

   641         if (u[0] == '/')

   642             u.prepend(currentEncodedURL->host);

   643         else if (u[0] == '#')

   644             u.prepend(currentEncodedURL->file);

   645         else

   646             u.prepend(currentEncodedURL->path);

   647         cleanpath(u);

   648     }

   649     pseudoState = historyContains(u) ? PseudoVisited : PseudoLink;

   650 }

   651 

   652 #ifdef STYLE_SHARING_STATS

   653 static int fraction = 0;

   654 static int total = 0;

   655 #endif

   656 

   657 static const unsigned cStyleSearchThreshold = 10;

   658 

   659 Node* CSSStyleSelector::locateCousinList(Element* parent, unsigned depth)

   660 {

   661     if (parent && parent->isStyledElement()) {

   662         StyledElement* p = static_cast<StyledElement*>(parent);

   663         if (!p->inlineStyleDecl() && !p->hasID()) {

   664             Node* r = p->previousSibling();

   665             unsigned subcount = 0;

   666             RenderStyle* st = p->renderStyle();

   667             while (r) {

   668                 if (r->renderStyle() == st)

   669                     return r->lastChild();

   670                 if (subcount++ == cStyleSearchThreshold)

   671                     return 0;

   672                 r = r->previousSibling();

   673             }

   674             if (!r && depth < cStyleSearchThreshold)

   675                 r = locateCousinList(static_cast<Element*>(parent->parentNode()), depth + 1);

   676             while (r) {

   677                 if (r->renderStyle() == st)

   678                     return r->lastChild();

   679                 if (subcount++ == cStyleSearchThreshold)

   680                     return 0;

   681                 r = r->previousSibling();

   682             }

   683         }

   684     }

   685     return 0;

   686 }

   687 

   688 bool CSSStyleSelector::canShareStyleWithElement(Node* n)

   689 {

   690     if (n->isStyledElement()) {

   691         StyledElement* s = static_cast<StyledElement*>(n);

   692         RenderStyle* style = s->renderStyle();

   693         if (style && !style->unique() &&

   694             (s->tagQName() == element->tagQName()) && !s->hasID() &&

   695             (s->hasClass() == element->hasClass()) && !s->inlineStyleDecl() &&

   696             (s->hasMappedAttributes() == styledElement->hasMappedAttributes()) &&

   697             (s->isLink() == element->isLink()) && 

   698             !style->affectedByAttributeSelectors() &&

   699             (s->hovered() == element->hovered()) &&

   700             (s->active() == element->active()) &&

   701             (s->focused() == element->focused()) &&

   702             (s != s->document()->getCSSTarget() && element != element->document()->getCSSTarget()) &&

   703             (s->getAttribute(typeAttr) == element->getAttribute(typeAttr)) &&

   704             (s->getAttribute(readonlyAttr) == element->getAttribute(readonlyAttr))) {

   705             bool isControl = s->isControl();

   706             if (isControl != element->isControl())

   707                 return false;

   708             if (isControl && (s->isEnabled() != element->isEnabled()) ||

   709                              (s->isIndeterminate() != element->isIndeterminate()) ||

   710                              (s->isChecked() != element->isChecked()))

   711                 return false;

   712             

   713             bool classesMatch = true;

   714             if (s->hasClass()) {

   715                 const AtomicString& class1 = element->getAttribute(classAttr);

   716                 const AtomicString& class2 = s->getAttribute(classAttr);

   717                 classesMatch = (class1 == class2);

   718             }

   719             

   720             if (classesMatch) {

   721                 bool mappedAttrsMatch = true;

   722                 if (s->hasMappedAttributes())

   723                     mappedAttrsMatch = s->mappedAttributes()->mapsEquivalent(styledElement->mappedAttributes());

   724                 if (mappedAttrsMatch) {

   725                     bool linksMatch = true;

   726                     if (s->isLink()) {

   727                         // We need to check to see if the visited state matches.

   728                         Color linkColor = element->document()->linkColor();

   729                         Color visitedColor = element->document()->visitedLinkColor();

   730                         if (pseudoState == PseudoUnknown)

   731                             checkPseudoState(element, style->pseudoState() != PseudoAnyLink || linkColor != visitedColor);

   732                         linksMatch = (pseudoState == style->pseudoState());

   733                     }

   734                     

   735                     if (linksMatch)

   736                         return true;

   737                 }

   738             }

   739         }

   740     }

   741     return false;

   742 }

   743 

   744 RenderStyle* CSSStyleSelector::locateSharedStyle()

   745 {

   746     if (styledElement && !styledElement->inlineStyleDecl() && !styledElement->hasID() &&

   747         !styledElement->document()->usesSiblingRules()) {

   748         // Check previous siblings.

   749         unsigned count = 0;

   750         Node* n;

   751         for (n = element->previousSibling(); n && !n->isElementNode(); n = n->previousSibling());

   752         while (n) {

   753             if (canShareStyleWithElement(n))

   754                 return n->renderStyle();

   755             if (count++ == cStyleSearchThreshold)

   756                 return 0;

   757             for (n = n->previousSibling(); n && !n->isElementNode(); n = n->previousSibling());

   758         }

   759         if (!n) 

   760             n = locateCousinList(static_cast<Element*>(element->parentNode()));

   761         while (n) {

   762             if (canShareStyleWithElement(n))

   763                 return n->renderStyle();

   764             if (count++ == cStyleSearchThreshold)

   765                 return 0;

   766             for (n = n->previousSibling(); n && !n->isElementNode(); n = n->previousSibling());

   767         }        

   768     }

   769     return 0;

   770 }

   771 

   772 void CSSStyleSelector::matchUARules(int& firstUARule, int& lastUARule)

   773 {

   774     // First we match rules from the user agent sheet.

   775     CSSRuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")

   776         ? defaultPrintStyle : defaultStyle;

   777     matchRules(userAgentStyleSheet, firstUARule, lastUARule);

   778 

   779     // In quirks mode, we match rules from the quirks user agent sheet.

   780     if (!strictParsing)

   781         matchRules(defaultQuirksStyle, firstUARule, lastUARule);

   782         

   783     // If we're in view source mode, then we match rules from the view source style sheet.

   784     if (m_document->frame() && m_document->frame()->inViewSourceMode())

   785         matchRules(defaultViewSourceStyle, firstUARule, lastUARule);

   786 }

   787 

   788 // If resolveForRootDefault is true, style based on user agent style sheet only. This is used in media queries, where

   789 // relative units are interpreted according to document root element style, styled only with UA stylesheet

   790 

   791 RenderStyle* CSSStyleSelector::styleForElement(Element* e, RenderStyle* defaultParent, bool allowSharing, bool resolveForRootDefault)

   792 {

   793     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer

   794     // will vanish if a style recalc happens during loading.

   795     if (allowSharing && !e->document()->haveStylesheetsLoaded() && !e->renderer()) {

   796         if (!styleNotYetAvailable) {

   797             styleNotYetAvailable = ::new RenderStyle;

   798             styleNotYetAvailable->ref();

   799             styleNotYetAvailable->setDisplay(NONE);

   800             styleNotYetAvailable->font().update();

   801         }

   802         styleNotYetAvailable->ref();

   803         e->document()->setHasNodesWithPlaceholderStyle();

   804         return styleNotYetAvailable;

   805     }

   806     

   807     initElementAndPseudoState(e);

   808     if (allowSharing) {

   809         style = locateSharedStyle();

   810 #ifdef STYLE_SHARING_STATS

   811         fraction += style != 0;

   812         total++;

   813         printf("Sharing %d out of %d\n", fraction, total);

   814 #endif

   815         if (style) {

   816             style->ref();

   817             return style;

   818         }

   819     }

   820     initForStyleResolve(e, defaultParent);

   821 

   822     if (resolveForRootDefault) {

   823         style = ::new RenderStyle();

   824         // don't ref, because we want to delete this, but we cannot unref it

   825     } else {

   826         style = new (e->document()->renderArena()) RenderStyle();

   827         style->ref();

   828     }

   829     if (parentStyle)

   830         style->inheritFrom(parentStyle);

   831     else

   832         parentStyle = style;

   833 

   834     int firstUARule = -1, lastUARule = -1;

   835     int firstUserRule = -1, lastUserRule = -1;

   836     int firstAuthorRule = -1, lastAuthorRule = -1;

   837     matchUARules(firstUARule, lastUARule);

   838 

   839     if (!resolveForRootDefault) {

   840         // 4. Now we check user sheet rules.

   841         matchRules(m_userStyle, firstUserRule, lastUserRule);

   842 

   843         // 5. Now check author rules, beginning first with presentational attributes

   844         // mapped from HTML.

   845         if (styledElement) {

   846             // Ask if the HTML element has mapped attributes.

   847             if (styledElement->hasMappedAttributes()) {

   848                 // Walk our attribute list and add in each decl.

   849                 const NamedMappedAttrMap* map = styledElement->mappedAttributes();

   850                 for (unsigned i = 0; i < map->length(); i++) {

   851                     MappedAttribute* attr = map->attributeItem(i);

   852                     if (attr->decl()) {

   853                         lastAuthorRule = m_matchedDecls.size();

   854                         if (firstAuthorRule == -1)

   855                             firstAuthorRule = lastAuthorRule;

   856                         addMatchedDeclaration(attr->decl());

   857                     }

   858                 }

   859             }

   860 

   861             // Now we check additional mapped declarations.

   862             // Tables and table cells share an additional mapped rule that must be applied

   863             // after all attributes, since their mapped style depends on the values of multiple attributes.

   864             CSSMutableStyleDeclaration* attributeDecl = styledElement->additionalAttributeStyleDecl();

   865             if (attributeDecl) {

   866                 lastAuthorRule = m_matchedDecls.size();

   867                 if (firstAuthorRule == -1)

   868                     firstAuthorRule = lastAuthorRule;

   869                 addMatchedDeclaration(attributeDecl);

   870             }

   871         }

   872     

   873         // 6. Check the rules in author sheets next.

   874         matchRules(m_authorStyle, firstAuthorRule, lastAuthorRule);

   875     

   876         // 7. Now check our inline style attribute.

   877         if (styledElement) {

   878             CSSMutableStyleDeclaration* inlineDecl = styledElement->inlineStyleDecl();

   879             if (inlineDecl) {

   880                 lastAuthorRule = m_matchedDecls.size();

   881                 if (firstAuthorRule == -1)

   882                     firstAuthorRule = lastAuthorRule;

   883                 addMatchedDeclaration(inlineDecl);

   884             }

   885         }

   886     }

   887 

   888     // Now we have all of the matched rules in the appropriate order.  Walk the rules and apply

   889     // high-priority properties first, i.e., those properties that other properties depend on.

   890     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important

   891     // and (4) normal important.

   892     m_lineHeightValue = 0;

   893     applyDeclarations(true, false, 0, m_matchedDecls.size() - 1);

   894     if (!resolveForRootDefault) {

   895         applyDeclarations(true, true, firstAuthorRule, lastAuthorRule);

   896         applyDeclarations(true, true, firstUserRule, lastUserRule);

   897     }

   898     applyDeclarations(true, true, firstUARule, lastUARule);

   899     

   900     // If our font got dirtied, go ahead and update it now.

   901     if (fontDirty)

   902         updateFont();

   903 

   904     // Line-height is set when we are sure we decided on the font-size

   905     if (m_lineHeightValue)

   906         applyProperty(CSS_PROP_LINE_HEIGHT, m_lineHeightValue);

   907 

   908     // Now do the normal priority UA properties.

   909     applyDeclarations(false, false, firstUARule, lastUARule);

   910     

   911     // Cache our border and background so that we can examine them later.

   912     cacheBorderAndBackground();

   913     

   914     // Now do the author and user normal priority properties and all the !important properties.

   915     if (!resolveForRootDefault) {

   916         applyDeclarations(false, false, lastUARule + 1, m_matchedDecls.size() - 1);

   917         applyDeclarations(false, true, firstAuthorRule, lastAuthorRule);

   918         applyDeclarations(false, true, firstUserRule, lastUserRule);

   919     }

   920     applyDeclarations(false, true, firstUARule, lastUARule);

   921     

   922     // If our font got dirtied by one of the non-essential font props, 

   923     // go ahead and update it a second time.

   924     if (fontDirty)

   925         updateFont();

   926     

   927     // Clean up our style object's display and text decorations (among other fixups).

   928     adjustRenderStyle(style, e);

   929 

   930     // If we are a link, cache the determined pseudo-state.

   931     if (e->isLink())

   932         style->setPseudoState(pseudoState);

   933 

   934     // If we have first-letter pseudo style, do not share this style

   935     if (style->hasPseudoStyle(RenderStyle::FIRST_LETTER))

   936         style->setUnique();

   937 

   938     // Now return the style.

   939     return style;

   940 }

   941 

   942 RenderStyle* CSSStyleSelector::pseudoStyleForElement(RenderStyle::PseudoId pseudo, Element* e, RenderStyle* parentStyle)

   943 {

   944     if (!e)

   945         return 0;

   946 

   947     initElementAndPseudoState(e);

   948     initForStyleResolve(e, parentStyle);

   949     pseudoStyle = pseudo;

   950     

   951     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking

   952     // those rules.

   953     

   954     // Check UA, user and author rules.

   955     int firstUARule = -1, lastUARule = -1, firstUserRule = -1, lastUserRule = -1, firstAuthorRule = -1, lastAuthorRule = -1;

   956     matchUARules(firstUARule, lastUARule);

   957     matchRules(m_userStyle, firstUserRule, lastUserRule);

   958     matchRules(m_authorStyle, firstAuthorRule, lastAuthorRule);

   959     

   960     if (m_matchedDecls.isEmpty())

   961         return 0;

   962     

   963     style = new (e->document()->renderArena()) RenderStyle();

   964     style->ref();

   965     if (parentStyle)

   966         style->inheritFrom(parentStyle);

   967     else

   968         parentStyle = style;

   969     style->noninherited_flags._styleType = pseudoStyle;

   970     

   971     m_lineHeightValue = 0;

   972     // High-priority properties.

   973     applyDeclarations(true, false, 0, m_matchedDecls.size() - 1);

   974     applyDeclarations(true, true, firstAuthorRule, lastAuthorRule);

   975     applyDeclarations(true, true, firstUserRule, lastUserRule);

   976     applyDeclarations(true, true, firstUARule, lastUARule);

   977     

   978     // If our font got dirtied, go ahead and update it now.

   979     if (fontDirty)

   980         updateFont();

   981 

   982     // Line-height is set when we are sure we decided on the font-size

   983     if (m_lineHeightValue)

   984         applyProperty(CSS_PROP_LINE_HEIGHT, m_lineHeightValue);

   985     

   986     // Now do the normal priority properties.

   987     applyDeclarations(false, false, firstUARule, lastUARule);

   988     

   989     // Cache our border and background so that we can examine them later.

   990     cacheBorderAndBackground();

   991     

   992     applyDeclarations(false, false, lastUARule + 1, m_matchedDecls.size() - 1);

   993     applyDeclarations(false, true, firstAuthorRule, lastAuthorRule);

   994     applyDeclarations(false, true, firstUserRule, lastUserRule);

   995     applyDeclarations(false, true, firstUARule, lastUARule);

   996     

   997     // If our font got dirtied by one of the non-essential font props, 

   998     // go ahead and update it a second time.

   999     if (fontDirty)

  1000         updateFont();

  1001     // Clean up our style object's display and text decorations (among other fixups).

  1002     adjustRenderStyle(style, 0);

  1003 

  1004     // Now return the style.

  1005     return style;

  1006 }

  1007 

  1008 static void addIntrinsicMargins(RenderStyle* style)

  1009 {

  1010     // Intrinsic margin value.

  1011     const int intrinsicMargin = 2;

  1012     

  1013     // FIXME: Using width/height alone and not also dealing with min-width/max-width is flawed.

  1014     // FIXME: Using "quirk" to decide the margin wasn't set is kind of lame.

  1015     if (style->width().isIntrinsicOrAuto()) {

  1016         if (style->marginLeft().quirk())

  1017             style->setMarginLeft(Length(intrinsicMargin, Fixed));

  1018         if (style->marginRight().quirk())

  1019             style->setMarginRight(Length(intrinsicMargin, Fixed));

  1020     }

  1021 

  1022     if (style->height().isAuto()) {

  1023         if (style->marginTop().quirk())

  1024             style->setMarginTop(Length(intrinsicMargin, Fixed));

  1025         if (style->marginBottom().quirk())

  1026             style->setMarginBottom(Length(intrinsicMargin, Fixed));

  1027     }

  1028 }

  1029 

  1030 void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, Element *e)

  1031 {

  1032     // Cache our original display.

  1033     style->setOriginalDisplay(style->display());

  1034 

  1035     if (style->display() != NONE) {

  1036         // If we have a <td> that specifies a float property, in quirks mode we just drop the float

  1037         // property.

  1038         // Sites also commonly use display:inline/block on <td>s and <table>s.  In quirks mode we force

  1039         // these tags to retain their display types.

  1040         if (!strictParsing && e) {

  1041             if (e->hasTagName(tdTag)) {

  1042                 style->setDisplay(TABLE_CELL);

  1043                 style->setFloating(FNONE);

  1044             }

  1045             else if (e->hasTagName(tableTag))

  1046                 style->setDisplay(style->isDisplayInlineType() ? INLINE_TABLE : TABLE);

  1047         }

  1048 

  1049         // Tables never support the -webkit-* values for text-align and will reset back to the default.

  1050         if (e && e->hasTagName(tableTag) && (style->textAlign() == WEBKIT_LEFT || style->textAlign() == WEBKIT_CENTER || style->textAlign() == WEBKIT_RIGHT))

  1051             style->setTextAlign(TAAUTO);

  1052 

  1053         // Frames and framesets never honor position:relative or position:absolute.  This is necessary to

  1054         // fix a crash where a site tries to position these objects.  They also never honor display.

  1055         if (e && (e->hasTagName(frameTag) || e->hasTagName(framesetTag))) {

  1056             style->setPosition(StaticPosition);

  1057             style->setDisplay(BLOCK);

  1058         }

  1059 

  1060         // Table headers with a text-align of auto will change the text-align to center.

  1061         if (e && e->hasTagName(thTag) && style->textAlign() == TAAUTO)

  1062             style->setTextAlign(CENTER);

  1063         

  1064         // Mutate the display to BLOCK or TABLE for certain cases, e.g., if someone attempts to

  1065         // position or float an inline, compact, or run-in.  Cache the original display, since it

  1066         // may be needed for positioned elements that have to compute their static normal flow

  1067         // positions.  We also force inline-level roots to be block-level.

  1068         if (style->display() != BLOCK && style->display() != TABLE && style->display() != BOX &&

  1069             (style->position() == AbsolutePosition || style->position() == FixedPosition || style->floating() != FNONE ||

  1070              (e && e->document()->documentElement() == e))) {

  1071             if (style->display() == INLINE_TABLE)

  1072                 style->setDisplay(TABLE);

  1073             else if (style->display() == INLINE_BOX)

  1074                 style->setDisplay(BOX);

  1075             else if (style->display() == LIST_ITEM) {

  1076                 // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk,

  1077                 // but only in quirks mode.

  1078                 if (!strictParsing && style->floating() != FNONE)

  1079                     style->setDisplay(BLOCK);

  1080             }

  1081             else

  1082                 style->setDisplay(BLOCK);

  1083         }

  1084         

  1085         // After performing the display mutation, check table rows.  We do not honor position:relative on

  1086         // table rows or cells.  This has been established in CSS2.1 (and caused a crash in containingBlock()

  1087         // on some sites).

  1088         if ((style->display() == TABLE_HEADER_GROUP || style->display() == TABLE_ROW_GROUP ||

  1089              style->display() == TABLE_FOOTER_GROUP || style->display() == TABLE_ROW || style->display() == TABLE_CELL) &&

  1090              style->position() == RelativePosition)

  1091             style->setPosition(StaticPosition);

  1092     }

  1093 

  1094     // Make sure our z-index value is only applied if the object is positioned,

  1095     // relatively positioned, or transparent.

  1096     if (style->position() == StaticPosition && style->opacity() == 1.0f)

  1097         style->setHasAutoZIndex();

  1098 

  1099     // Auto z-index becomes 0 for the root element and transparent objects.  This prevents

  1100     // cases where objects that should be blended as a single unit end up with a non-transparent

  1101     // object wedged in between them.

  1102     if (style->hasAutoZIndex() && ((e && e->document()->documentElement() == e) || style->opacity() < 1.0f))

  1103         style->setZIndex(0);

  1104     

  1105     // Button, legend, input, select and textarea all consider width values of 'auto' to be 'intrinsic'.

  1106     // This will be important when we use block flows for all form controls.

  1107     if (e && (e->hasTagName(legendTag) || e->hasTagName(buttonTag) || e->hasTagName(inputTag) ||

  1108               e->hasTagName(selectTag) || e->hasTagName(textareaTag))) {

  1109         if (style->width().isAuto())

  1110             style->setWidth(Length(Intrinsic));

  1111     }

  1112 

  1113     // Finally update our text decorations in effect, but don't allow text-decoration to percolate through

  1114     // tables, inline blocks, inline tables, or run-ins.

  1115     if (style->display() == TABLE || style->display() == INLINE_TABLE || style->display() == RUN_IN

  1116         || style->display() == INLINE_BLOCK || style->display() == INLINE_BOX)

  1117         style->setTextDecorationsInEffect(style->textDecoration());

  1118     else

  1119         style->addToTextDecorationsInEffect(style->textDecoration());

  1120     

  1121     // If either overflow value is not visible, change to auto.

  1122     if (style->overflowX() == OMARQUEE && style->overflowY() != OMARQUEE)

  1123         style->setOverflowY(OMARQUEE);

  1124     else if (style->overflowY() == OMARQUEE && style->overflowX() != OMARQUEE)

  1125         style->setOverflowX(OMARQUEE);

  1126     else if (style->overflowX() == OVISIBLE && style->overflowY() != OVISIBLE)

  1127         style->setOverflowX(OAUTO);

  1128     else if (style->overflowY() == OVISIBLE && style->overflowX() != OVISIBLE)

  1129         style->setOverflowY(OAUTO);

  1130 

  1131     // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.

  1132     // FIXME: Eventually table sections will support auto and scroll.

  1133     if (style->display() == TABLE || style->display() == INLINE_TABLE ||

  1134         style->display() == TABLE_ROW_GROUP || style->display() == TABLE_ROW) {