tests: Use runPendingTasks instead of WebThread::enterRunLoop()/exitRunLoop()

Source/web/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 54 matching lines @@
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/LayerCompositor.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Page.h"
 #include "core/testing/NullExecutionContext.h"
 #include "core/testing/URLTestHelpers.h"
+#include "core/testing/UnitTestHelpers.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/mediastream/MediaStreamRegistry.h"
 #include "platform/DragImage.h"
 #include "platform/PlatformResourceLoader.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/network/ResourceError.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "platform/weborigin/SchemeRegistry.h"
@@ skipping 23 matching lines @@
 #include "public/web/WebSpellCheckClient.h"
 #include "public/web/WebTextCheckingCompletion.h"
 #include "public/web/WebTextCheckingResult.h"
 #include "public/web/WebViewClient.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 #include "wtf/Forward.h"
 #include "wtf/dtoa/utils.h"
-#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <map>
 #include <v8.h>
 
-namespace {
+using blink::URLTestHelpers::toKURL;
+using blink::FrameTestHelpers::UseMockScrollbarSettings;
+using blink::testing::runPendingTasks;
+using testing::ElementsAre;
 
-using blink::URLTestHelpers::toKURL;
-using blink::FrameTestHelpers::runPendingTasks;
-using blink::FrameTestHelpers::UseMockScrollbarSettings;
-using namespace blink;
+namespace blink {
 
 const int touchPointPadding = 32;
 
 #define EXPECT_RECT_EQ(expected, actual) \
     do { \
         EXPECT_EQ(expected.x(), actual.x()); \
         EXPECT_EQ(expected.y(), actual.y()); \
         EXPECT_EQ(expected.width(), actual.width()); \
         EXPECT_EQ(expected.height(), actual.height()); \
     } while (false)
 
 #define EXPECT_POINT_EQ(expected, actual) \
     do { \
         EXPECT_EQ(expected.x(), actual.x()); \
         EXPECT_EQ(expected.y(), actual.y()); \
     } while (false)
 
 #define EXPECT_FLOAT_POINT_EQ(expected, actual) \
     do { \
         EXPECT_FLOAT_EQ(expected.x(), actual.x()); \
         EXPECT_FLOAT_EQ(expected.y(), actual.y()); \
     } while (false)
 
-
-class WebFrameTest : public testing::Test {
+class WebFrameTest : public ::testing::Test {
 protected:
     WebFrameTest()
         : m_baseURL("http://internal.test/")
         , m_notBaseURL("http://external.test/")
         , m_chromeURL("chrome://")
     {
     }
 
     virtual ~WebFrameTest()
     {
@@ skipping 224 matching lines @@
         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);
     }
 }
 
-class WebFrameCSSCallbackTest : public testing::Test {
+class WebFrameCSSCallbackTest : public ::testing::Test {
 protected:
     WebFrameCSSCallbackTest()
     {
         m_frame = m_helper.initializeAndLoad("about:blank", true, &m_client)->mainFrame()->toWebLocalFrame();
     }
 
     ~WebFrameCSSCallbackTest()
     {
         EXPECT_EQ(1U, m_client.m_matchedSelectors.size());
     }
@@ skipping 41 matching lines @@
         "</style>"
         "<div class=\"initial_on\"></div>"
         "<div class=\"initial_off\"></div>");
 
     std::vector<WebString> selectors;
     selectors.push_back(WebString::fromUTF8("div.initial_on"));
     m_frame->document().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("div.initial_on"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("div.initial_on"));

[dcheng, 2015/03/02 14:25:29]

FWIW, I'd prefer to see this in a separate changelist for future cleanup changes
like this.

[sadrul, 2015/03/02 16:01:35]

Indeed. Unfortunately, I had to include the change in this CL to fix build
failures (because of conflicting 'testing' namespace)

 
     // Check that adding a watched selector calls back for already-present nodes.
     selectors.push_back(WebString::fromUTF8("div.initial_off"));
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
     EXPECT_EQ(2, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("div.initial_off", "div.initial_on"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("div.initial_off", "div.initial_on"));
 
     // Check that we can turn off callbacks for certain selectors.
     doc().watchCSSSelectors(WebVector<WebString>());
     m_frame->view()->layout();
     runPendingTasks();
     EXPECT_EQ(3, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre());
+    EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, SharedLayoutStyle)
 {
     // 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));
 
     executeScript(
         "i1 = document.createElement('span');"
         "i1.id = 'first_span';"
         "document.body.appendChild(i1)");
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     // Adding a second element that shares a LayoutStyle shouldn't call back.
     // We use <span>s to avoid default style rules that can set
     // LayoutStyle::unique().
     executeScript(
         "i2 = document.createElement('span');"
         "i2.id = 'second_span';"
         "i1 = document.getElementById('first_span');"
         "i1.parentNode.insertBefore(i2, i1.nextSibling);");
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     // Removing the first element shouldn't call back.
     executeScript(
         "i1 = document.getElementById('first_span');"
         "i1.parentNode.removeChild(i1);");
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     // But removing the second element *should* call back.
     executeScript(
         "i2 = document.getElementById('second_span');"
         "i2.parentNode.removeChild(i2);");
     EXPECT_EQ(2, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre());
+    EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, CatchesAttributeChange)
 {
     loadHTML("<span></span>");
 
     std::vector<WebString> selectors;
     selectors.push_back(WebString::fromUTF8("span[attr=\"value\"]"));
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     runPendingTasks();
 
     EXPECT_EQ(0, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre());
+    EXPECT_THAT(matchedSelectors(), ElementsAre());
 
     executeScript(
         "document.querySelector('span').setAttribute('attr', 'value');");
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span[attr=\"value\"]"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span[attr=\"value\"]"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, DisplayNone)
 {
     loadHTML("<div style='display:none'><span></span></div>");
 
     std::vector<WebString> selectors;
     selectors.push_back(WebString::fromUTF8("span"));
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     runPendingTasks();
 
     EXPECT_EQ(0, updateCount()) << "Don't match elements in display:none trees.";
 
     executeScript(
         "d = document.querySelector('div');"
         "d.style.display = 'block';");
     EXPECT_EQ(1, updateCount()) << "Match elements when they become displayed.";
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     executeScript(
         "d = document.querySelector('div');"
         "d.style.display = 'none';");
     EXPECT_EQ(2, updateCount()) << "Unmatch elements when they become undisplayed.";
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre());
+    EXPECT_THAT(matchedSelectors(), ElementsAre());
 
     executeScript(
         "s = document.querySelector('span');"
         "s.style.display = 'none';");
     EXPECT_EQ(2, updateCount()) << "No effect from no-display'ing a span that's already undisplayed.";
 
     executeScript(
         "d = document.querySelector('div');"
         "d.style.display = 'block';");
     EXPECT_EQ(2, updateCount()) << "No effect from displaying a div whose span is display:none.";
 
     executeScript(
         "s = document.querySelector('span');"
         "s.style.display = 'inline';");
     EXPECT_EQ(3, updateCount()) << "Now the span is visible and produces a callback.";
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     executeScript(
         "s = document.querySelector('span');"
         "s.style.display = 'none';");
     EXPECT_EQ(4, updateCount()) << "Undisplaying the span directly should produce another callback.";
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre());
+    EXPECT_THAT(matchedSelectors(), ElementsAre());
 }
 
 TEST_F(WebFrameCSSCallbackTest, Reparenting)
 {
     loadHTML(
         "<div id='d1'><span></span></div>"
         "<div id='d2'></div>");
 
     std::vector<WebString> selectors;
     selectors.push_back(WebString::fromUTF8("span"));
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
 
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 
     executeScript(
         "s = document.querySelector('span');"
         "d2 = document.getElementById('d2');"
         "d2.appendChild(s);");
     EXPECT_EQ(1, updateCount()) << "Just moving an element that continues to match shouldn't send a spurious callback.";
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, MultiSelector)
 {
     loadHTML("<span></span>");
 
     // 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"));
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
 
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span", "span, p"));
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span", "span, p"));
 }
 
 TEST_F(WebFrameCSSCallbackTest, InvalidSelector)
 {
     loadHTML("<p><span></span></p>");
 
     // Build a list with one valid selector and one invalid.
     std::vector<WebString> selectors;
     selectors.push_back(WebString::fromUTF8("span"));
     selectors.push_back(WebString::fromUTF8("[")); // Invalid.
     selectors.push_back(WebString::fromUTF8("p span")); // Not compound.
     doc().watchCSSSelectors(WebVector<WebString>(selectors));
     m_frame->view()->layout();
     runPendingTasks();
 
     EXPECT_EQ(1, updateCount());
-    EXPECT_THAT(matchedSelectors(), testing::ElementsAre("span"))
+    EXPECT_THAT(matchedSelectors(), ElementsAre("span"))
         << "An invalid selector shouldn't prevent other selectors from matching.";
 }
 
 TEST_F(WebFrameTest, DispatchMessageEventWithOriginCheck)
 {
     registerMockedHttpURLLoad("postmessage_test.html");
 
     // Pass true to enable JavaScript.
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "postmessage_test.html", true);
@@ skipping 6675 matching lines @@
     EXPECT_FALSE(frameClient.wasLastProvisionalLoadATransition());
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 
     // Neither should a page reload.
     localFrame->reload();
     EXPECT_EQ(4u, frameClient.provisionalLoadCount());
     EXPECT_FALSE(frameClient.wasLastProvisionalLoadATransition());
     EXPECT_EQ(1u, frameClient.navigationalDataReceivedCount());
 }
 
-} // namespace
+} // namespace blink