Add a WebDocument::watchCssSelectors(selectors)

Source/core/dom/CSSSelectorWatch.cpp

Index: Source/core/dom/CSSSelectorWatch.cpp
diff --git a/Source/core/dom/CSSSelectorWatch.cpp b/Source/core/dom/CSSSelectorWatch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..493ae7ae1390b11daadba5f43456bd441cf02d96
--- /dev/null
+++ b/Source/core/dom/CSSSelectorWatch.cpp
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/dom/CSSSelectorWatch.h"
+
+#include "core/css/CSSParser.h"
+#include "core/css/CSSSelectorList.h"
+#include "core/css/StylePropertySet.h"
+#include "core/dom/Document.h"
+#include "core/dom/ScriptExecutionContext.h"
+#include "core/loader/FrameLoaderClient.h"
+#include "core/page/Frame.h"
+#include "core/rendering/style/StyleRareNonInheritedData.h"
+
+namespace WebCore {
+
+// The address of this string is important; its value is just documentation.
+static const char kSupplementName[] = "CSSSelectorWatch";
+
+CSSSelectorWatch::CSSSelectorWatch(Document* document)
+    : m_document(document)
+    , m_callbackSelectorChangeTimer(this, &CSSSelectorWatch::callbackSelectorChangeTimerFired)
+    , m_timerExpirations(0)
+{
+}
+
+CSSSelectorWatch* CSSSelectorWatch::from(Document* document)
+{
+    CSSSelectorWatch* watch = static_cast<CSSSelectorWatch*>(Supplement<ScriptExecutionContext>::from(document, kSupplementName));
+    if (!watch) {
+        watch = new CSSSelectorWatch(document);
+        Supplement<ScriptExecutionContext>::provideTo(document, kSupplementName, adoptPtr(watch));
+    }
+    return watch;
+}
+
+void CSSSelectorWatch::restartTimer()
+{
+    if (m_callbackSelectorChangeTimer.isActive())
+        m_timerExpirations = 0;
+    else
+        m_callbackSelectorChangeTimer.startOneShot(0);
+}
+
+void CSSSelectorWatch::callbackSelectorChangeTimerFired(Timer<CSSSelectorWatch>*)
+{
+    if (m_addedSelectors.isEmpty() && m_removedSelectors.isEmpty()) {
+        m_timerExpirations = 0;
+        return;
+    }
+    if (m_timerExpirations < 1) {
+        m_timerExpirations++;
+        m_callbackSelectorChangeTimer.startOneShot(0);
+        return;
+    }
+    if (m_document->frame()) {
+        Vector<String> addedSelectors, removedSelectors;

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

We usually do one declaration per line.

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

Ah, sure.

+        copyToVector(m_addedSelectors, addedSelectors);
+        copyToVector(m_removedSelectors, removedSelectors);
+        m_document->frame()->loader()->client()->selectorMatchChanged(addedSelectors, removedSelectors);
+    }
+    m_addedSelectors.clear();
+    m_removedSelectors.clear();
+    m_timerExpirations = 0;
+}
+
+void CSSSelectorWatch::addSelectorMatches(const Vector<String>& selectors)
+{
+    for (unsigned i = 0; i < selectors.size(); ++i) {
+        const String& selector = selectors[i];
+        HashMap<String, int>::iterator count = m_matchingCallbackSelectors.find(selector);
+        if (count != m_matchingCallbackSelectors.end()) {
+            ++count->value;
+            continue;
+        }
+        restartTimer();
+
+        m_matchingCallbackSelectors.set(selector, 1);
+        if (m_removedSelectors.contains(selector))
+            m_removedSelectors.remove(selector);
+        else
+            m_addedSelectors.add(selector);
+    }
+}
+
+void CSSSelectorWatch::removeSelectorMatches(const Vector<String>& selectors)
+{
+    for (unsigned i = 0; i < selectors.size(); ++i) {
+        const String& selector = selectors[i];
+        HashMap<String, int>::iterator count = m_matchingCallbackSelectors.find(selector);
+        if (count == m_matchingCallbackSelectors.end())
+            continue;
+        --count->value;
+        if (!count->value) {
+            restartTimer();
+
+            m_matchingCallbackSelectors.remove(count);
+            if (m_addedSelectors.contains(selector))
+                m_addedSelectors.remove(selector);
+            else
+                m_removedSelectors.add(selector);
+        }
+    }
+}
+
+static bool allCompound(const CSSSelectorList& selectorList)
+{
+    for (const CSSSelector* selector = selectorList.first(); selector; selector = selectorList.next(selector)) {
+        if (!selector->isCompound())
+            return false;
+    }
+    return true;
+}
+
+void CSSSelectorWatch::watchCSSSelectors(const Vector<String>& selectors)
+{
+    m_watchedCallbackSelectors.clear();
+    CSSParserContext context(UASheetMode);
+    CSSParser parser(context);
+
+    const CSSProperty callbackProperty(CSSPropertyInternalCallback, CSSPrimitiveValue::createIdentifier(CSSValueInternalPresence));
+    const RefPtr<StylePropertySet> callbackPropertySet = ImmutableStylePropertySet::create(&callbackProperty, 1, UASheetMode);
+
+    CSSSelectorList selectorList;
+    for (unsigned i = 0; i < selectors.size(); ++i) {
+        parser.parseSelector(selectors[i], selectorList);
+        if (!selectorList.isValid())
+            continue;
+
+        // Only accept Compound Selectors, since they're cheaper to match.
+        if (!allCompound(selectorList))
+            continue;
+
+        RefPtr<StyleRule> rule = StyleRule::create();
+        rule->wrapperAdoptSelectorList(selectorList);
+        rule->setProperties(callbackPropertySet);
+        m_watchedCallbackSelectors.append(rule.release());
+    }
+    m_document->styleResolverChanged(RecalcStyleDeferred);

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

You should really be calling m_document->modifiedStyleSheet() and modifying your
own StyleSheet instance instead of hooking into the selector like you're doing.

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

It turned out to be complicated to create an actual StyleSheet instance. After
an in-person conversation, I added a Document::changedSelectorWatch() so that
this can be cleaned up after the main CL is in.

+}
+
+} // namespace WebCore