Add a WebDocument::watchCssSelectors(selectors)

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 25 matching lines @@
 #include "core/accessibility/AXObjectCache.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/css/CSSParser.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/PropertySetCSSStyleDeclaration.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Attr.h"
 #include "core/dom/Attribute.h"
+#include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/CustomElement.h"
 #include "core/dom/CustomElementRegistrationContext.h"
 #include "core/dom/DatasetDOMStringMap.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentSharedObjectPool.h"
 #include "core/dom/ElementRareData.h"
 #include "core/dom/EventDispatcher.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 1274 matching lines @@
 }
 
 void Element::attach(const AttachContext& context)
 {
     PostAttachCallbackDisabler callbackDisabler(this);
     StyleResolverParentPusher parentPusher(this);
     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
 
     NodeRenderingContext(this, context.resolvedStyle).createRendererForElementIfNeeded();
 
+    updateCallbackSelectors(Add);
+
     createPseudoElementIfNeeded(BEFORE);
 
     // When a shadow root exists, it does the work of attaching the children.
     if (ElementShadow* shadow = this->shadow()) {
         parentPusher.push();
         shadow->attach(context);
     } else if (firstChild())
         parentPusher.push();
 
     ContainerNode::attach(context);
@@ skipping 21 matching lines @@
 {
     if (RuntimeEnabledFeatures::cssRegionsEnabled() && inNamedFlow() && document()->renderView())
         document()->renderView()->flowThreadController()->unregisterNamedFlowContentNode(this);
 }
 
 void Element::detach(const AttachContext& context)
 {
     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
     unregisterNamedFlowContentNode();
     cancelFocusAppearanceUpdate();
+    updateCallbackSelectors(Remove);
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
         data->setPseudoElement(BEFORE, 0);
         data->setPseudoElement(AFTER, 0);
         data->setPseudoElement(BACKDROP, 0);
         data->clearComputedStyle();
         data->resetDynamicRestyleObservations();
         data->setIsInsideRegion(false);
 
         // Only clear the style state if we're not going to reuse the style from recalcStyle.
@@ skipping 63 matching lines @@
     return document()->styleResolver()->styleForElement(this);
 }
 
 bool Element::recalcStyle(StyleChange change)
 {
     ASSERT(document()->inStyleRecalc());
 
     if (hasCustomStyleCallbacks())
         willRecalcStyle(change);
 
+    class SelectorWatchUpdater {
+    public:
+        SelectorWatchUpdater(Element* element)
+            : m_element(element)
+        {
+            m_element->updateCallbackSelectors(Remove);
+        }
+
+        ~SelectorWatchUpdater()
+        {
+            m_element->updateCallbackSelectors(Add);
+        }
+
+    private:
+        Element* const m_element;
+    };
+    SelectorWatchUpdater watchUpdater(this);
+
     // Ref currentStyle in case it would otherwise be deleted when setting the new style in the renderer.
     RefPtr<RenderStyle> currentStyle = renderStyle();
     bool hasParentStyle = static_cast<bool>(parentRenderStyle());
     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
     bool hasIndirectAdjacentRules = childrenAffectedByForwardPositionalRules();
 
     if (hasRareData() && (change > NoChange || needsStyleRecalc())) {
         ElementRareData* data = elementRareData();
         data->resetStyleState();
         data->clearComputedStyle();
@@ skipping 965 matching lines @@
 }
 
 void Element::cancelFocusAppearanceUpdate()
 {
     if (hasRareData())
         elementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
     if (document()->focusedElement() == this)
         document()->cancelFocusAppearanceUpdate();
 }
 
+void Element::updateCallbackSelectors(AddOrRemove addOrRemove)
+{
+    if (!renderStyle())
+        return;
+    const Vector<String>& callbackSelectors = renderStyle()->callbackSelectors();
+    if (callbackSelectors.isEmpty())
+        return;
+
+    CSSSelectorWatch* selectorWatch = CSSSelectorWatch::from(document());
+    switch (addOrRemove) {
+    case Add: {
+        ElementRareData* rareData = ensureElementRareData();
+        if (!rareData->renderStyleWatchedSelectorsRepresentedInSelectorWatch()) {
+            selectorWatch->addSelectorMatches(callbackSelectors);
+            rareData->setRenderStyleWatchedSelectorsRepresentedInSelectorWatch(true);
+        }
+        break;
+    }
+    case Remove:
+        if (hasRareData() && elementRareData()->renderStyleWatchedSelectorsRepresentedInSelectorWatch()) {
+            selectorWatch->removeSelectorMatches(callbackSelectors);
+            elementRareData()->setRenderStyleWatchedSelectorsRepresentedInSelectorWatch(false);
+        }
+        break;
+    }
+}
+
 void Element::normalizeAttributes()
 {
     if (!hasAttributes())
         return;
     for (unsigned i = 0; i < attributeCount(); ++i) {
         if (RefPtr<Attr> attr = attrIfExists(attributeItem(i)->name()))
             attr->normalize();
     }
 }
 
@@ skipping 1234 matching lines @@
     return 0;
 }
 
 Attribute* UniqueElementData::attributeItem(unsigned index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
     return &m_attributeVector.at(index);
 }
 
 } // namespace WebCore