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 26 matching lines @@
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/css/CSSAnimations.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 1262 matching lines @@
     if (hasRareData() && styleChangeType() == LazyAttachStyleChange) {
         ElementRareData* data = elementRareData();
         data->clearComputedStyle();
         data->resetDynamicRestyleObservations();
         if (!context.resolvedStyle)
             data->resetStyleState();
     }
 
     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 {

[esprehn, 2013/09/04 06:08:28]

Don't put classes inside methods. This needs to be at the top of the file or in
its own file.

[Jeffrey Yasskin, 2013/09/12 22:09:59]

It's no longer necessary. :)

+    public:
+        SelectorWatchUpdater(Element* element)
+            : m_element(element)
+        {
+            m_element->updateCallbackSelectors(Remove);

[esprehn, 2013/09/04 06:08:28]

This is not right, why are you removing and adding on every recalcStyle? You do
this on every element as it walks down the tree, even if the style is identical.

I think you want recalcOwnStyle() in here and you want to only mess around with
this if the style changed?

[Jeffrey Yasskin, 2013/09/12 22:09:59]

Yep, using recalcOwnStyle() cleaned this up a lot.

+        }
+
+        ~SelectorWatchUpdater()
+        {
+            m_element->updateCallbackSelectors(Add);
+        }
+
+    private:
+        Element* const m_element;
+    };
+    SelectorWatchUpdater watchUpdater(this);
+
     if (hasRareData() && (change > NoChange || needsStyleRecalc())) {
         ElementRareData* data = elementRareData();
         data->resetStyleState();
         data->clearComputedStyle();
     }
 
     // Active InsertionPoints have no renderers so they never need to go through a recalc.
     if ((change >= Inherit || needsStyleRecalc()) && parentRenderStyle() && !isActiveInsertionPoint(this))
         change = recalcOwnStyle(change);
 
@@ 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;

[esprehn, 2013/09/04 06:08:28]

Don't call RenderStyle repeatedly, you want to call it once and save the value.

[Jeffrey Yasskin, 2013/09/12 22:09:59]

Obsolete. :)

+    const Vector<String>& callbackSelectors = renderStyle()->callbackSelectors();
+    if (callbackSelectors.isEmpty())

[esprehn, 2013/09/04 06:08:28]

The check should be outside the function call since it'll be inline simple
checks unless you have the "slow stuff"


RenderStyle* style = renderStyle()
if (style && style->hasCallbackSelectors())
  doSomethingHere();

[Jeffrey Yasskin, 2013/09/12 22:09:59]

Done.

+        return;
+
+    CSSSelectorWatch* selectorWatch = CSSSelectorWatch::from(document());
+    switch (addOrRemove) {
+    case Add: {
+        ElementRareData* rareData = ensureElementRareData();
+        if (!rareData->renderStyleWatchedSelectorsRepresentedInSelectorWatch()) {
+            selectorWatch->addSelectorMatches(callbackSelectors);
+            rareData->setRenderStyleWatchedSelectorsRepresentedInSelectorWatch(true);
+        }
+        break;

[esprehn, 2013/09/04 06:08:28]

These should be two separate methods and get rid of the enum and switch.

[Jeffrey Yasskin, 2013/09/12 22:09:59]

Refactored away.

+    }
+    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 1186 matching lines @@
     return 0;
 }
 
 Attribute* UniqueElementData::attributeItem(unsigned index)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
     return &m_attributeVector.at(index);
 }
 
 } // namespace WebCore