Add a WebDocument::watchCssSelectors(selectors)

Source/core/css/resolver/StyleResolver.cpp

 /*
  * 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, 2011, 2012, 2013 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/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 190 matching lines @@
 
     if (root)
         m_rootDefaultStyle = styleForElement(root, 0, DisallowStyleSharing, MatchOnlyUserAgentRules);
 
     if (m_rootDefaultStyle && view)
         m_medium = adoptPtr(new MediaQueryEvaluator(view->mediaType(), view->frame(), m_rootDefaultStyle.get()));
 
     m_styleTree.clear();
 
     DocumentStyleSheetCollection* styleSheetCollection = document->styleSheetCollection();
-    m_ruleSets.initUserStyle(styleSheetCollection, *m_medium, *this);
+    m_ruleSets.initUserStyle(styleSheetCollection, document->watchedCallbackSelectors(), *m_medium, *this);
 
 #if ENABLE(SVG_FONTS)
     if (document->svgExtensions()) {
         const HashSet<SVGFontFaceElement*>& svgFontFaceElements = document->svgExtensions()->svgFontFaceElements();
         HashSet<SVGFontFaceElement*>::const_iterator end = svgFontFaceElements.end();
         for (HashSet<SVGFontFaceElement*>::const_iterator it = svgFontFaceElements.begin(); it != end; ++it)
             fontSelector()->addFontFaceRule((*it)->fontFaceRule());
     }
 #endif
 
@@ skipping 845 matching lines @@
             s_styleNotYetAvailable->setDisplay(NONE);
             s_styleNotYetAvailable->font().update(m_fontSelector);
         }
         element->document()->setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     StyleResolverState& state = m_state;
     state.initForStyleResolve(document(), element, defaultParent, regionForStyling);
     if (sharingBehavior == AllowStyleSharing && !state.distributedToInsertionPoint()) {
-        RenderStyle* sharedStyle = locateSharedStyle();
+        RefPtr<RenderStyle> sharedStyle = locateSharedStyle();
         if (sharedStyle) {
             state.clear();
-            return sharedStyle;
+            return sharedStyle.release();
         }
     }
 
     if (state.parentStyle()) {
         state.setStyle(RenderStyle::create());
         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
     } else {
         state.setStyle(defaultStyleForElement());
         state.setParentStyle(RenderStyle::clone(state.style()));
     }
@@ skipping 30 matching lines @@
     if (matchingBehavior == MatchOnlyUserAgentRules)
         matchUARules(collector);
     else
         matchAllRules(collector, m_matchAuthorAndUserStyles, matchingBehavior != MatchAllRulesExcludingSMIL);
 
     applyMatchedProperties(collector.matchedResult(), element);
 
     // Clean up our style object's display and text decorations (among other fixups).
     adjustRenderStyle(state.style(), state.parentStyle(), element);
 
-    state.clear(); // Clear out for the next resolve.
-
     document()->didAccessStyleResolver();
 
     if (element->hasTagName(bodyTag))
         document()->textLinkColors().setTextColor(state.style()->visitedDependentColor(CSSPropertyColor));
 
-    // Now return the style.
-    return state.takeStyle();
+    // Now return the style and clear out for the next resolve.
+    return state.takeStyleAndClear();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(const RenderStyle* elementStyle, const StyleKeyframe* keyframe, KeyframeValue& keyframeValue)
 {
     MatchResult result;
     if (keyframe->properties())
         result.addMatchedProperties(keyframe->properties());
 
     ASSERT(!m_state.style());
 
@@ skipping 97 matching lines @@
     if (initialListSize > 0 && (list[list.size() - 1].key() != 1)) {
         static StyleKeyframe* hundredPercentKeyframe;
         if (!hundredPercentKeyframe) {
             hundredPercentKeyframe = StyleKeyframe::create().leakRef();
             hundredPercentKeyframe->setKeyText("100%");
         }
         KeyframeValue keyframeValue(1, 0);
         keyframeValue.setStyle(styleForKeyframe(elementStyle, hundredPercentKeyframe, keyframeValue));
         list.insert(keyframeValue);
     }
+    m_state.clear();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::pseudoStyleForElement(Element* e, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle)
 {
     ASSERT(parentStyle);
     if (!e)
         return 0;
 
     StyleResolverState& state = m_state;
 
@@ skipping 13 matching lines @@
     // Check UA, user and author rules.
     ElementRuleCollector collector(this, state);
     collector.setPseudoStyleRequest(pseudoStyleRequest);
     matchUARules(collector);
 
     if (m_matchAuthorAndUserStyles) {
         matchUserRules(collector, false);
         matchAuthorRules(collector, false);
     }
 
-    if (collector.matchedResult().matchedProperties.isEmpty())
+    if (collector.matchedResult().matchedProperties.isEmpty()) {
+        state.clear();
         return 0;
+    }
 
     state.style()->setStyleType(pseudoStyleRequest.pseudoId);
 
     applyMatchedProperties(collector.matchedResult(), e);
 
     // Clean up our style object's display and text decorations (among other fixups).
     adjustRenderStyle(state.style(), m_state.parentStyle(), 0);
 
     // Start loading resources referenced by this style.
     m_styleResourceLoader.loadPendingResources(m_state.style(), m_state.elementStyleResources());
 
     document()->didAccessStyleResolver();
 
     // Now return the style.
-    return state.takeStyle();
+    return state.takeStyleAndClear();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForPage(int pageIndex)
 {
     m_state.initForStyleResolve(document(), document()->documentElement()); // m_rootElementStyle will be set to the document style.
 
     m_state.setStyle(RenderStyle::create());
     m_state.style()->inheritFrom(m_state.rootElementStyle());
 
     PageRuleCollector collector(m_state, pageIndex);
@@ skipping 19 matching lines @@
         applyProperty(CSSPropertyLineHeight, m_state.lineHeightValue());
 
     applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // Start loading resources referenced by this style.
     m_styleResourceLoader.loadPendingResources(m_state.style(), m_state.elementStyleResources());
 
     document()->didAccessStyleResolver();
 
     // Now return the style.
-    return m_state.takeStyle();
+    return m_state.takeStyleAndClear();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 {
     m_state.setStyle(RenderStyle::create());
     // Make sure our fonts are initialized if we don't inherit them from our parent style.
     if (Settings* settings = documentSettings()) {
         initializeFontStyle(settings);
         m_state.style()->font().update(fontSelector());
     } else
@@ skipping 422 matching lines @@
             matchUserRules(collector, rulesToInclude & EmptyCSSRules);
     }
 
     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
 
         // Check the rules in author sheets.
         matchAuthorRules(collector, rulesToInclude & EmptyCSSRules);
     }
 
+    m_state.clear();
     return collector.matchedRuleList();
 }
 
 // -------------------------------------------------------------------------------------
 // this is mostly boring stuff on how to apply a certain rule to the renderstyle...
 
 Length StyleResolver::convertToIntLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier)
 {
     return primitiveValue ? primitiveValue->convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
 }
@@ skipping 117 matching lines @@
         break;
     }
     return false;
 }
 
 template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyProperties(const StylePropertySet* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
 {
     ASSERT((propertyWhitelistType != PropertyWhitelistRegion) || m_state.regionForStyling());
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willProcessRule(document(), rule, this);
+#if ENABLE(CSS_CALLBACKS)
+    m_state.setRule(rule);
+#endif
 
     unsigned propertyCount = properties->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         StylePropertySet::PropertyReference current = properties->propertyAt(i);
         if (isImportant != current.isImportant())
             continue;
         if (inheritedOnly && !current.isInherited()) {
             // If the property value is explicitly inherited, we need to apply further non-inherited properties
             // as they might override the value inherited here. For this reason we don't allow declarations with
             // explicitly inherited properties to be cached.
@@ skipping 243 matching lines @@
     if (!isCacheableInMatchedPropertiesCache(state.element(), state.style(), state.parentStyle()))
         return;
     addToMatchedPropertiesCache(state.style(), state.parentStyle(), cacheHash, matchResult);
 }
 
 void StyleResolver::applyPropertyToStyle(CSSPropertyID id, CSSValue* value, RenderStyle* style)
 {
     m_state.initForStyleResolve(document(), 0, style);
     m_state.setStyle(style);
     applyPropertyToCurrentStyle(id, value);
+    m_state.clear();
 }
 
 void StyleResolver::applyPropertyToCurrentStyle(CSSPropertyID id, CSSValue* value)
 {
     if (value)
         applyProperty(id, value);
 }
 
 bool StyleResolver::useSVGZoomRules()
 {
@@ skipping 607 matching lines @@
     }
     case CSSPropertyWebkitTapHighlightColor: {
         HANDLE_INHERIT_AND_INITIAL(tapHighlightColor, TapHighlightColor);
         if (!primitiveValue)
             break;
 
         Color col = m_state.resolveColorFromPrimitiveValue(primitiveValue);
         state.style()->setTapHighlightColor(col);
         return;
     }
+#if ENABLE(CSS_CALLBACKS)
+    case CSSPropertyInternalCallback: {
+        if (isInherit || isInitial)
+            return;
+        if (primitiveValue) {
+            switch (primitiveValue->getValueID()) {
+            case CSSValueInternalPresence:
+                state.style()->addCallbackSelector(
+                    state.rule()->selectorList().selectorsText(),
+                    state.element()->document());
+                return;
+            default:
+                break;
+            }
+        }
+        break;
+    }
+#endif
     case CSSPropertyInvalid:
         return;
     // Directional properties are resolved by resolveDirectionAwareProperty() before the switch.
     case CSSPropertyWebkitBorderEndColor:
     case CSSPropertyWebkitBorderEndStyle:
     case CSSPropertyWebkitBorderEndWidth:
     case CSSPropertyWebkitBorderStartColor:
     case CSSPropertyWebkitBorderStartStyle:
     case CSSPropertyWebkitBorderStartWidth:
     case CSSPropertyWebkitBorderBeforeColor:
@@ skipping 605 matching lines @@
     info.addMember(m_state, "state");
 
     // FIXME: move this to a place where it would be called only once?
     info.addMember(CSSDefaultStyleSheets::defaultStyle, "defaultStyle");
     info.addMember(CSSDefaultStyleSheets::defaultQuirksStyle, "defaultQuirksStyle");
     info.addMember(CSSDefaultStyleSheets::defaultPrintStyle, "defaultPrintStyle");
     info.addMember(CSSDefaultStyleSheets::defaultViewSourceStyle, "defaultViewSourceStyle");
 }
 
 } // namespace WebCore