Add a WebDocument::watchCssSelectors(selectors)

Source/WebKit/chromium/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 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
@@ skipping 14 matching lines @@
  * 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 "WebFrame.h"
 
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include "FrameTestHelpers.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "URLTestHelpers.h"
 #include "WebDataSource.h"
 #include "WebDocument.h"
 #include "WebFindOptions.h"
 #include "WebFormElement.h"
 #include "WebFrameClient.h"
@@ skipping 21 matching lines @@
 #include "core/page/Settings.h"
 #include "core/platform/ScrollbarTheme.h"
 #include "core/platform/graphics/FloatRect.h"
 #include "core/platform/network/ResourceError.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/RenderLayerCompositor.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextAutosizer.h"
 #include "v8.h"
 #include "public/platform/Platform.h"
+#include "public/platform/WebCString.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebUnitTestSupport.h"
 #include "public/platform/WebURLResponse.h"
 #include "wtf/dtoa/utils.h"
 #include "wtf/Forward.h"
+#include <map>
 
 using namespace WebKit;
 using WebCore::Document;
 using WebCore::DocumentMarker;
 using WebCore::Element;
 using WebCore::FloatRect;
 using WebCore::HitTestRequest;
 using WebCore::Range;
 using WebKit::URLTestHelpers::toKURL;
 using WebKit::FrameTestHelpers::runPendingTasks;
@@ skipping 169 matching lines @@
     FrameTestHelpers::loadFrame(m_webView->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Clobbered'))");
 
     // Required to see any updates in contentAsText.
     m_webView->layout();
 
     // Now retrieve the frame's text and ensure it wasn't modified by running javascript.
     std::string content = std::string(m_webView->mainFrame()->contentAsText(1024).utf8().data());
     EXPECT_EQ(std::string::npos, content.find("Clobbered"));
 }
 
+#if ENABLE(CSS_CALLBACKS)
+struct CssCallbackWebFrameClient : public WebFrameClient {
+    CssCallbackWebFrameClient() : m_updateCount(0) { }
+    virtual void didMatchCss(WebFrame* frame, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) OVERRIDE
+    {
+        ++m_updateCount;
+        std::set<std::string>& frameSelectors = m_matchedSelectors[frame];
+        for (size_t i = 0; i < newlyMatchingSelectors.size(); ++i) {
+            std::string selector = newlyMatchingSelectors[i].utf8();
+            EXPECT_EQ(0U, frameSelectors.count(selector)) << selector;
+            frameSelectors.insert(selector);
+        }
+        for (size_t i = 0; i < stoppedMatchingSelectors.size(); ++i) {
+            std::string selector = stoppedMatchingSelectors[i].utf8();
+            EXPECT_EQ(1U, frameSelectors.count(selector)) << selector;
+            frameSelectors.erase(selector);
+        }
+    }
+
+    std::map<WebFrame*, std::set<std::string> > m_matchedSelectors;
+    int m_updateCount;
+};
+
+TEST_F(WebFrameTest, CssCallbackAuthorStyleSheet)
+{
+    CssCallbackWebFrameClient client;
+    WebView* webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true, &client);
+    WebFrame* frame = webView->mainFrame();
+
+    frame->loadHTMLString(
+        "<style>"
+        // This stylesheet checks that the internal property and value can't be
+        // set by a stylesheet, only WebDocument::watchCssSelectors().
+        "div.initial_on { -internal-callback: none; }"
+        "div.initial_off { -internal-callback: -internal-presence; }"
+        "</style>"
+        "<div class=\"initial_on\"></div>"
+        "<div class=\"initial_off\"></div>",
+        toKURL("about:blank"));
+    runPendingTasks();
+
+    std::vector<WebString> selectors;
+    selectors.push_back(WebString::fromUTF8("div.initial_on"));
+    frame->document().watchCssSelectors(WebVector<WebString>(selectors));
+    runPendingTasks();
+    EXPECT_EQ(1, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("div.initial_on"));
+
+    WebDocument doc = frame->document();
+    // Check that adding a watched selector calls back for already-present nodes.
+    selectors.push_back(WebString::fromUTF8("div.initial_off"));
+    frame->document().watchCssSelectors(WebVector<WebString>(selectors));
+    runPendingTasks();
+    EXPECT_EQ(2, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("div.initial_off", "div.initial_on"));
+
+    // Check that we can turn off callbacks for certain selectors.
+    frame->document().watchCssSelectors(WebVector<WebString>());
+    runPendingTasks();
+    EXPECT_EQ(3, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre());
+
+    EXPECT_EQ(1U, client.m_matchedSelectors.size());
+    webView->close();
+}
+
+TEST_F(WebFrameTest, CssCallbackSharedRenderStyle)
+{
+    CssCallbackWebFrameClient client;
+    WebView* webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true, &client);
+    WebFrame* frame = webView->mainFrame();
+    WebDocument doc = frame->document();
+
+    // Check that adding an element calls back when it matches an existing rule.
+    std::vector<WebString> selectors;
+    selectors.push_back(WebString::fromUTF8("span"));
+    doc.watchCssSelectors(WebVector<WebString>(selectors));
+
+    frame->executeScript(WebScriptSource(
+        "i1 = document.createElement('span');"
+        "i1.id = 'first_span';"
+        "document.body.appendChild(i1)"));
+    runPendingTasks();
+    EXPECT_EQ(1, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("span"));
+
+    // Adding a second element that shares a RenderStyle shouldn't call back.
+    // We use <span>s to avoid default style rules that can set
+    // RenderStyle::unique().
+    frame->executeScript(WebScriptSource(
+        "i2 = document.createElement('span');"
+        "i2.id = 'second_span';"
+        "i1 = document.getElementById('first_span');"
+        "i1.parentNode.insertBefore(i2, i1.nextSibling);"));
+    runPendingTasks();
+    EXPECT_EQ(1, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("span"));
+
+    // Removing the first element shouldn't call back.
+    frame->executeScript(WebScriptSource(
+        "i1 = document.getElementById('first_span');"
+        "i1.parentNode.removeChild(i1);"));
+    runPendingTasks();
+    EXPECT_EQ(1, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("span"));
+
+    // But removing the second element *should* call back.
+    frame->executeScript(WebScriptSource(
+        "i2 = document.getElementById('second_span');"
+        "i2.parentNode.removeChild(i2);"));
+    runPendingTasks();
+    EXPECT_EQ(2, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre());
+
+    EXPECT_EQ(1U, client.m_matchedSelectors.size());
+    webView->close();
+}
+
+TEST_F(WebFrameTest, CssCallbackMultiSelector)
+{
+    CssCallbackWebFrameClient client;
+    WebView* webView = FrameTestHelpers::createWebViewAndLoad("about:blank", true, &client);
+    WebFrame* frame = webView->mainFrame();
+    frame->loadHTMLString("<span></span>", toKURL("about:blank"));
+    runPendingTasks();
+    WebDocument doc = frame->document();
+
+    // Check that selector lists match as the whole list, not as each element
+    // independently.
+    std::vector<WebString> selectors;
+    selectors.push_back(WebString::fromUTF8("span"));
+    selectors.push_back(WebString::fromUTF8("span,p"));
+    frame->document().watchCssSelectors(WebVector<WebString>(selectors));
+
+    runPendingTasks();
+    EXPECT_EQ(1, client.m_updateCount);
+    EXPECT_THAT(client.m_matchedSelectors[frame],
+        testing::ElementsAre("span", "span, p"));
+
+    EXPECT_EQ(1U, client.m_matchedSelectors.size());
+    webView->close();
+}
+#endif
+
 TEST_F(WebFrameTest, DispatchMessageEventWithOriginCheck)
 {
     registerMockedHttpURLLoad("postmessage_test.html");
 
     // Pass true to enable JavaScript.
     m_webView = FrameTestHelpers::createWebViewAndLoad(m_baseURL + "postmessage_test.html", true);
     
     // Send a message with the correct origin.
     WebSecurityOrigin correctOrigin(WebSecurityOrigin::create(toKURL(m_baseURL)));
     WebDOMEvent event = m_webView->mainFrame()->document().createEvent("MessageEvent");
@@ skipping 3123 matching lines @@
     frame->reload();
     Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
 
     m_webView->close();
     m_webView = 0;
 }
 
 
 } // namespace