Fix webkit_unit_tests to use the threaded parser and enable everywhere.

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 276 matching lines @@
     URLTestHelpers::registerMockedURLLoad(toKURL("http://www.test.com:0/" + fileName), WebString::fromUTF8(fileName));
 
     FrameTestHelpers::WebViewHelper webViewHelper;
 
     /// Pass true to enable JavaScript.
     webViewHelper.initializeAndLoad(m_baseURL + fileName, true);
 
     // Setting host to "hostname:" should be treated as "hostname:0".
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:location.host = 'www.test.com:'; void 0;");
 
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
-
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.textContent = location.href; void 0;");
-    // Required to see any updates in contentAsText.
-    runPendingTasks();
-    webViewHelper.webView()->layout();
 
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ("http://www.test.com:0/" + fileName, content);
 }
 
 TEST_F(WebFrameTest, LocationSetEmptyPort)
 {
     std::string fileName = "print-location-href.html";
     registerMockedHttpURLLoad(fileName);
     URLTestHelpers::registerMockedURLLoad(toKURL("http://www.test.com:0/" + fileName), WebString::fromUTF8(fileName));
 
     FrameTestHelpers::WebViewHelper webViewHelper;
 
     /// Pass true to enable JavaScript.
     webViewHelper.initializeAndLoad(m_baseURL + fileName, true);
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:location.port = ''; void 0;");
 
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
-
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.textContent = location.href; void 0;");
-    // Required to see any updates in contentAsText.
-    runPendingTasks();
-    webViewHelper.webView()->layout();
 
     std::string content = webViewHelper.webView()->mainFrame()->contentAsText(1024).utf8();
     EXPECT_EQ("http://www.test.com:0/" + fileName, content);
 }
 
 class CSSCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     CSSCallbackWebFrameClient() : m_updateCount(0) { }
     virtual void didMatchCSS(WebLocalFrame*, const WebVector<WebString>& newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) OVERRIDE;
 
@@ skipping 38 matching lines @@
     int updateCount() const
     {
         return m_client.m_updateCount;
     }
 
     const std::set<std::string>& matchedSelectors()
     {
         return m_client.m_matchedSelectors[m_frame];
     }
 
-    void loadHTML(const WebData& html)
+    void loadHTML(const std::string& html)
     {
-        m_frame->loadHTMLString(html, toKURL("about:blank"));
-        runPendingTasks();
+        FrameTestHelpers::loadHTMLString(m_frame, html, toKURL("about:blank"));
     }
 
     void executeScript(const WebString& code)
     {
         m_frame->executeScript(WebScriptSource(code));
         m_frame->view()->layout();
         runPendingTasks();
     }
 
     CSSCallbackWebFrameClient m_client;
@@ skipping 976 matching lines @@
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "wide_document_width_viewport.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     int wideDocumentWidth = 800;
     float minimumPageScaleFactor = viewportWidth / (float) wideDocumentWidth;
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
     EXPECT_EQ(minimumPageScaleFactor, webViewHelper.webView()->minimumPageScaleFactor());
 }
 
 TEST_F(WebFrameTest, WideViewportQuirkClobbersHeight)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-height-1000.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(false);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-height-1000.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, LayoutSize320Quirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport/viewport-30.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 600;
     int viewportHeight = 800;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport/viewport-30.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(600, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(800, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().height());
     EXPECT_EQ(1, webViewHelper.webView()->pageScaleFactor());
 
     // The magic number to snap to device-width is 320, so test that 321 is
     // respected.
     WebCore::Document* document = webViewHelper.webViewImpl()->page()->mainFrame()->document();
     WebCore::ViewportDescription description = document->viewportDescription();
@@ skipping 30 matching lines @@
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     webViewHelper.webView()->settings()->setViewportMetaLayoutSizeQuirk(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-zero-values.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->layout();
     EXPECT_EQ(viewportWidth, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(1.0f, webViewHelper.webView()->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, OverflowHiddenDisablesScrolling)
 {
     registerMockedHttpURLLoad("body-overflow-hidden.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     WebCore::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_FALSE(view->userInputScrollable(WebCore::VerticalScrollbar));
 }
 
 TEST_F(WebFrameTest, IgnoreOverflowHiddenQuirk)
 {
     registerMockedHttpURLLoad("body-overflow-hidden.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client);
     webViewHelper.webView()->settings()->setIgnoreMainFrameOverflowHiddenQuirk(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "body-overflow-hidden.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     WebCore::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_TRUE(view->userInputScrollable(WebCore::VerticalScrollbar));
 }
 
 TEST_F(WebFrameTest, NonZeroValuesNoQuirk)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("viewport-nonzero-values.html");
 
     FixedLayoutTestWebViewClient client;
     client.m_screenInfo.deviceScaleFactor = 1;
     int viewportWidth = 640;
     int viewportHeight = 480;
     float expectedPageScaleFactor = 0.5f;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, &client, enableViewportSettings);
     webViewHelper.webView()->settings()->setViewportMetaZeroValuesQuirk(true);
     webViewHelper.webView()->settings()->setWideViewportQuirkEnabled(true);
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "viewport-nonzero-values.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     webViewHelper.webView()->resize(WebSize(viewportWidth, viewportHeight));
 
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 
     webViewHelper.webView()->settings()->setUseWideViewport(true);
     webViewHelper.webView()->layout();
     EXPECT_EQ(viewportWidth / expectedPageScaleFactor, webViewHelper.webViewImpl()->mainFrameImpl()->frameView()->layoutSize().width());
     EXPECT_EQ(expectedPageScaleFactor, webViewHelper.webView()->pageScaleFactor());
 }
@@ skipping 46 matching lines @@
 TEST_F(WebFrameTest, setPageScaleFactorBeforeFrameHasView)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
 
     float pageScaleFactor = 3;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:html", true, 0, 0);
     webViewHelper.webView()->setPageScaleFactor(pageScaleFactor);
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "fixed_layout.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     WebCore::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_EQ(pageScaleFactor, view->visibleContentScaleFactor());
 }
 
 TEST_F(WebFrameTest, pageScaleFactorWrittenToHistoryItem)
 {
     UseMockScrollbarSettings mockScrollbarSettings;
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FixedLayoutTestWebViewClient client;
@@ skipping 557 matching lines @@
 
     int viewWidth = 500;
     int viewHeight = 500;
 
     OwnPtr<FakeCompositingWebViewClient> fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, fakeCompositingWebViewClient.get(), &configueCompositingWebView);
 
     webViewHelper.webView()->resize(WebSize(viewWidth, viewHeight));
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "large-div.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
-    webViewHelper.webView()->layout();
 
     WebCore::FrameView* view = webViewHelper.webViewImpl()->mainFrameImpl()->frameView();
     EXPECT_TRUE(view->renderView()->compositor()->layerForHorizontalScrollbar());
     EXPECT_TRUE(view->renderView()->compositor()->layerForVerticalScrollbar());
 
     webViewHelper.webView()->resize(WebSize(viewWidth * 10, viewHeight * 10));
     webViewHelper.webView()->layout();
     EXPECT_FALSE(view->renderView()->compositor()->layerForHorizontalScrollbar());
     EXPECT_FALSE(view->renderView()->compositor()->layerForVerticalScrollbar());
 }
@@ skipping 461 matching lines @@
 {
     // Test for case in http://crbug.com/73104. Reloading a frame very quickly
     // would sometimes call decidePolicyForNavigation with isRedirect=true
     registerMockedHttpURLLoad("form.html");
 
     TestReloadDoesntRedirectWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "form.html", false, &webFrameClient);
 
     webViewHelper.webView()->mainFrame()->reload(true);
-    // start reload before request is delivered.
-    webViewHelper.webView()->mainFrame()->reload(true);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    // start another reload before request is delivered.
+    FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 }
 
+class ReloadWithOverrideURLTask : public WebThread::Task {
+public:
+    ReloadWithOverrideURLTask(WebFrame* frame, const WebCore::KURL& url, bool ignoreCache)
+        : m_frame(frame), m_url(url), m_ignoreCache(ignoreCache)
+    {
+    }
+
+    virtual void run() OVERRIDE
+    {
+        m_frame->reloadWithOverrideURL(m_url, m_ignoreCache);
+    }
+
+private:
+    WebFrame* const m_frame;
+    const WebCore::KURL m_url;
+    const bool m_ignoreCache;
+};
+
 TEST_F(WebFrameTest, ReloadWithOverrideURLPreservesState)
 {
     const std::string firstURL = "find.html";
     const std::string secondURL = "form.html";
     const std::string thirdURL = "history.html";
     const float pageScaleFactor = 1.1684f;
     const int pageWidth = 640;
     const int pageHeight = 480;
 
     registerMockedHttpURLLoad(firstURL);
     registerMockedHttpURLLoad(secondURL);
     registerMockedHttpURLLoad(thirdURL);
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + firstURL, true);
     webViewHelper.webViewImpl()->resize(WebSize(pageWidth, pageHeight));
     webViewHelper.webViewImpl()->mainFrame()->setScrollOffset(WebSize(pageWidth / 4, pageHeight / 4));
     webViewHelper.webViewImpl()->setPageScaleFactor(pageScaleFactor);
 
     WebSize previousOffset = webViewHelper.webViewImpl()->mainFrame()->scrollOffset();
     float previousScale = webViewHelper.webViewImpl()->pageScaleFactor();
 
     // Reload the page using the cache.
-    webViewHelper.webViewImpl()->mainFrame()->reloadWithOverrideURL(toKURL(m_baseURL + secondURL), false);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    Platform::current()->currentThread()->postTask(
+        new ReloadWithOverrideURLTask(webViewHelper.webViewImpl()->mainFrame(), toKURL(m_baseURL + secondURL), false));
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webViewImpl()->mainFrame());
     ASSERT_EQ(previousOffset, webViewHelper.webViewImpl()->mainFrame()->scrollOffset());
     ASSERT_EQ(previousScale, webViewHelper.webViewImpl()->pageScaleFactor());
 
     // Reload the page while ignoring the cache.
-    webViewHelper.webViewImpl()->mainFrame()->reloadWithOverrideURL(toKURL(m_baseURL + thirdURL), true);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    Platform::current()->currentThread()->postTask(
+        new ReloadWithOverrideURLTask(webViewHelper.webViewImpl()->mainFrame(), toKURL(m_baseURL + thirdURL), true));
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webViewImpl()->mainFrame());
     ASSERT_EQ(previousOffset, webViewHelper.webViewImpl()->mainFrame()->scrollOffset());
     ASSERT_EQ(previousScale, webViewHelper.webViewImpl()->pageScaleFactor());
 }
 
 TEST_F(WebFrameTest, ReloadWhileProvisional)
 {
     // Test that reloading while the previous load is still pending does not cause the initial
     // request to get lost.
     registerMockedHttpURLLoad("fixed_layout.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize();
-    FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "fixed_layout.html");
+    WebURLRequest request;
+    request.initialize();
+    request.setURL(toKURL(m_baseURL + "fixed_layout.html"));
+    webViewHelper.webView()->mainFrame()->loadRequest(request);
     // start reload before first request is delivered.
-    webViewHelper.webView()->mainFrame()->reload(true);
-
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrameIgnoringCache(webViewHelper.webView()->mainFrame());
 
     WebDataSource* dataSource = webViewHelper.webView()->mainFrame()->dataSource();
     ASSERT_TRUE(dataSource);
     EXPECT_EQ(toKURL(m_baseURL + "fixed_layout.html"), toKURL(dataSource->request().url().spec()));
 }
 
 TEST_F(WebFrameTest, AppendRedirects)
 {
     const std::string firstURL = "about:blank";
     const std::string secondURL = "http://www.test.com";
@@ skipping 12 matching lines @@
     EXPECT_EQ(toKURL(secondURL), toKURL(redirects[1].spec().data()));
 }
 
 TEST_F(WebFrameTest, IframeRedirect)
 {
     registerMockedHttpURLLoad("iframe_redirect.html");
     registerMockedHttpURLLoad("visible_iframe.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_redirect.html", true);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests(); // Load the iframe.
+    // Pump pending requests one more time. The test page loads script that navigates.
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     WebFrame* iframe = webViewHelper.webView()->findFrameByName(WebString::fromUTF8("ifr"));
     ASSERT_TRUE(iframe);
     WebDataSource* iframeDataSource = iframe->dataSource();
     ASSERT_TRUE(iframeDataSource);
     WebVector<WebURL> redirects;
     iframeDataSource->redirectChain(redirects);
     ASSERT_EQ(2U, redirects.size());
     EXPECT_EQ(toKURL("about:blank"), toKURL(redirects[0].spec().data()));
     EXPECT_EQ(toKURL("http://www.test.com/visible_iframe.html"), toKURL(redirects[1].spec().data()));
@@ skipping 120 matching lines @@
     v8::HandleScope handleScope(v8::Isolate::GetCurrent());
 
     registerMockedHttpURLLoad("context_notifications_test.html");
     registerMockedHttpURLLoad("context_notifications_test_frame.html");
 
     ContextLifetimeTestWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "context_notifications_test.html", true, &webFrameClient);
 
     // Refresh, we should get two release notifications and two more create notifications.
-    webViewHelper.webView()->mainFrame()->reload(false);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
     ASSERT_EQ(4u, webFrameClient.createNotifications.size());
     ASSERT_EQ(2u, webFrameClient.releaseNotifications.size());
 
     // The two release notifications we got should be exactly the same as the first two create notifications.
     for (size_t i = 0; i < webFrameClient.releaseNotifications.size(); ++i) {
       EXPECT_TRUE(webFrameClient.releaseNotifications[i]->Equals(
           webFrameClient.createNotifications[webFrameClient.createNotifications.size() - 3 - i]));
     }
 
     // The last two create notifications should be for the current frames and context.
@@ skipping 117 matching lines @@
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     // We set the size because it impacts line wrapping, which changes the
     // resulting text value.
     webViewHelper.webView()->resize(WebSize(640, 480));
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<div>Foo bar</div><div></div>baz";
     WebCore::KURL testURL = toKURL("about:blank");
-    frame->loadHTMLString(simpleSource, testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
     // Make sure it comes out OK.
     const std::string expected("Foo bar\nbaz");
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ(expected, text.utf8());
 
     // Try reading the same one with clipping of the text.
     const int length = 5;
     text = frame->contentAsText(length);
     EXPECT_EQ(expected.substr(0, length), text.utf8());
 
     // Now do a new test with a subframe.
     const char outerFrameSource[] = "Hello<iframe></iframe> world";
-    frame->loadHTMLString(outerFrameSource, testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(frame, outerFrameSource, testURL);
 
     // Load something into the subframe.
     WebFrame* subframe = frame->firstChild();
     ASSERT_TRUE(subframe);
-    subframe->loadHTMLString("sub<p>text", testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(subframe, "sub<p>text", testURL);
 
     text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello world\n\nsub\ntext", text.utf8());
 
     // Get the frame text where the subframe separator falls on the boundary of
     // what we'll take. There used to be a crash in this case.
     text = frame->contentAsText(12);
     EXPECT_EQ("Hello world", text.utf8());
 }
 
 TEST_F(WebFrameTest, GetFullHtmlOfPage)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Generate a simple test case.
     const char simpleSource[] = "<p>Hello</p><p>World</p>";
     WebCore::KURL testURL = toKURL("about:blank");
-    frame->loadHTMLString(simpleSource, testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(frame, simpleSource, testURL);
 
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello\n\nWorld", text.utf8());
 
     const std::string html = frame->contentAsMarkup().utf8();
 
     // Load again with the output html.
-    frame->loadHTMLString(WebData(html.c_str(), html.length()), testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(frame, html, testURL);
 
     EXPECT_EQ(html, frame->contentAsMarkup().utf8());
 
     text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("Hello\n\nWorld", text.utf8());
 
     // Test selection check
     EXPECT_FALSE(frame->hasSelection());
     frame->executeCommand(WebString::fromUTF8("SelectAll"));
     EXPECT_TRUE(frame->hasSelection());
@@ skipping 12 matching lines @@
 };
 
 TEST_F(WebFrameTest, ExecuteScriptDuringDidCreateScriptContext)
 {
     registerMockedHttpURLLoad("hello_world.html");
 
     TestExecuteScriptDuringDidCreateScriptContext webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "hello_world.html", true, &webFrameClient);
 
-    webViewHelper.webView()->mainFrame()->reload();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(webViewHelper.webView()->mainFrame());
 }
 
 class FindUpdateWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     FindUpdateWebFrameClient()
         : m_findResultsAreReady(false)
         , m_count(-1)
     {
     }
 
@@ skipping 914 matching lines @@
 class TestSubstituteDataWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestSubstituteDataWebFrameClient()
         : m_commitCalled(false)
     {
     }
 
     virtual void didFailProvisionalLoad(WebLocalFrame* frame, const WebURLError& error)
     {
         frame->loadHTMLString("This should appear", toKURL("data:text/html,chromewebdata"), error.unreachableURL, true);
-        runPendingTasks();
     }
 
     virtual void didCommitProvisionalLoad(WebLocalFrame* frame, const WebHistoryItem&, WebHistoryCommitType)
     {
         if (frame->dataSource()->response().url() != WebURL(URLTestHelpers::toKURL("about:blank")))
             m_commitCalled = true;
     }
 
     bool commitCalled() const { return m_commitCalled; }
 
 private:
     bool m_commitCalled;
 };
 
 TEST_F(WebFrameTest, ReplaceNavigationAfterHistoryNavigation)
 {
     TestSubstituteDataWebFrameClient webFrameClient;
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true, &webFrameClient);
-    runPendingTasks();
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     // Load a url as a history navigation that will return an error. TestSubstituteDataWebFrameClient
     // will start a SubstituteData load in response to the load failure, which should get fully committed.
     // Due to https://bugs.webkit.org/show_bug.cgi?id=91685, FrameLoader::didReceiveData() wasn't getting
     // called in this case, which resulted in the SubstituteData document not getting displayed.
     WebURLError error;
     error.reason = 1337;
     error.domain = "WebFrameTest";
     std::string errorURL = "http://0.0.0.0";
     WebURLResponse response;
     response.initialize();
     response.setURL(URLTestHelpers::toKURL(errorURL));
     response.setMIMEType("text/html");
     response.setHTTPStatusCode(500);
     WebHistoryItem errorHistoryItem;
     errorHistoryItem.initialize();
     errorHistoryItem.setURLString(WebString::fromUTF8(errorURL.c_str(), errorURL.length()));
     Platform::current()->unitTestSupport()->registerMockedErrorURL(URLTestHelpers::toKURL(errorURL), response, error);
-    frame->loadHistoryItem(errorHistoryItem, WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::loadHistoryItem(frame, errorHistoryItem, WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
 
     WebString text = frame->contentAsText(std::numeric_limits<size_t>::max());
     EXPECT_EQ("This should appear", text.utf8());
     EXPECT_TRUE(webFrameClient.commitCalled());
 }
 
 class TestWillInsertBodyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestWillInsertBodyWebFrameClient() : m_numBodies(0), m_didLoad(false)
     {
@@ skipping 405 matching lines @@
 TEST_F(WebFrameTest, DidAccessInitialDocumentViaJavascriptUrl)
 {
     TestAccessInitialDocumentWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, &webFrameClient);
     runPendingTasks();
     EXPECT_FALSE(webFrameClient.m_didAccessInitialDocument);
 
     // Access the initial document from a javascript: URL.
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.body.appendChild(document.createTextNode('Modified'))");
-    runPendingTasks();
     EXPECT_TRUE(webFrameClient.m_didAccessInitialDocument);
 }
 
 // Fails on the WebKit XP (deps) bot. http://crbug.com/312192
 #if OS(WIN)
 TEST_F(WebFrameTest, DISABLED_DidAccessInitialDocumentBodyBeforeModalDialog)
 #else
 TEST_F(WebFrameTest, DidAccessInitialDocumentBodyBeforeModalDialog)
 #endif
 {
@@ skipping 272 matching lines @@
     WebCore::Document* document = webViewHelper.webViewImpl()->page()->mainFrame()->document();
     WebCore::KURL destination = toKURL(m_baseURL + "hello_world.html");
 
     // ctrl+click event
     RefPtrWillBeRawPtr<WebCore::Event> event = WebCore::MouseEvent::create(WebCore::EventTypeNames::click, false, false,
         document->domWindow(), 0, 0, 0, 0, 0, 0, 0, true, false, false, false, 0, nullptr, nullptr);
     WebCore::FrameLoadRequest frameRequest(document, WebCore::ResourceRequest(destination));
     frameRequest.setTriggeringEvent(event);
     WebCore::UserGestureIndicator gesture(WebCore::DefinitelyProcessingUserGesture);
     webViewHelper.webViewImpl()->page()->mainFrame()->loader().load(frameRequest);
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     // decidePolicyForNavigation should be called both for the original request and the ctrl+click.
     EXPECT_EQ(2, webFrameClient.decidePolicyCallCount());
 }
 
 TEST_F(WebFrameTest, BackToReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const WebCore::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     RefPtr<WebCore::HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
-    frame->loadHistoryItem(WebHistoryItem(firstItem.get()), WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::loadHistoryItem(frame, WebHistoryItem(firstItem.get()), WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
 
-    frame->reload();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
 }
 
 TEST_F(WebFrameTest, BackDuringChildFrameReload)
 {
     registerMockedHttpURLLoad("page_with_blank_iframe.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "page_with_blank_iframe.html", true);
     WebFrame* mainFrame = webViewHelper.webView()->mainFrame();
     const WebCore::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     WebFrame* childFrame = mainFrame->firstChild();
     ASSERT_TRUE(childFrame);
 
     // Start a history navigation, then have a different frame commit a navigation.
     // In this case, reload an about:blank frame, which will commit synchronously.
     // After the history navigation completes, both the appropriate document url and
     // the current history item should reflect the history navigation.
     registerMockedHttpURLLoad("white-1x1.png");
     WebHistoryItem item;
     item.initialize();
     WebURL historyURL(toKURL(m_baseURL + "white-1x1.png"));
     item.setURLString(historyURL.string());
     mainFrame->loadHistoryItem(item, WebHistoryDifferentDocumentLoad, WebURLRequest::UseProtocolCachePolicy);
 
-    childFrame->reload();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(childFrame);
     EXPECT_EQ(item.urlString(), mainFrame->document().url().string());
     EXPECT_EQ(item.urlString(), WebString(mainFrameLoader.currentItem()->urlString()));
 }
 
 TEST_F(WebFrameTest, ReloadPost)
 {
     registerMockedHttpURLLoad("reload_post.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "reload_post.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), "javascript:document.forms[0].submit()");
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    // Pump requests one more time after the javascript URL has executed to
+    // trigger the actual POST load request.
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
     EXPECT_EQ(WebString::fromUTF8("POST"), frame->dataSource()->request().httpMethod());
 
-    frame->reload();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(frame);
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
     EXPECT_EQ(WebNavigationTypeFormResubmitted, frame->dataSource()->navigationType());
 }
 
 TEST_F(WebFrameTest, LoadHistoryItemReload)
 {
     registerMockedHttpURLLoad("fragment_middle_click.html");
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const WebCore::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
     RefPtr<WebCore::HistoryItem> firstItem = mainFrameLoader.currentItem();
     EXPECT_TRUE(firstItem);
 
     registerMockedHttpURLLoad("white-1x1.png");
     FrameTestHelpers::loadFrame(frame, m_baseURL + "white-1x1.png");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_NE(firstItem.get(), mainFrameLoader.currentItem());
 
     // Cache policy overrides should take.
-    frame->loadHistoryItem(WebHistoryItem(firstItem), WebHistoryDifferentDocumentLoad, WebURLRequest::ReloadIgnoringCacheData);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::loadHistoryItem(frame, WebHistoryItem(firstItem), WebHistoryDifferentDocumentLoad, WebURLRequest::ReloadIgnoringCacheData);
     EXPECT_EQ(firstItem.get(), mainFrameLoader.currentItem());
     EXPECT_EQ(WebURLRequest::ReloadIgnoringCacheData, frame->dataSource()->request().cachePolicy());
 }
 
 
-class TestCachePolicyWebFrameClient : public WebFrameClient {
+class TestCachePolicyWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
-    TestCachePolicyWebFrameClient()
-        : m_policy(WebURLRequest::UseProtocolCachePolicy)
-        , m_client(0)
+    explicit TestCachePolicyWebFrameClient(TestCachePolicyWebFrameClient* parentClient)
+        : m_parentClient(parentClient)
+        , m_policy(WebURLRequest::UseProtocolCachePolicy)
+        , m_childClient(0)
         , m_willSendRequestCallCount(0)
         , m_childFrameCreationCount(0)
     {
     }
 
-    void setChildWebFrameClient(WebFrameClient* client) { m_client = client; }
+    void setChildWebFrameClient(TestCachePolicyWebFrameClient* client) { m_childClient = client; }
     WebURLRequest::CachePolicy cachePolicy() const { return m_policy; }
     int willSendRequestCallCount() const { return m_willSendRequestCallCount; }
     int childFrameCreationCount() const { return m_childFrameCreationCount; }
 
     virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString&)
     {
+        ASSERT(m_childClient);
         m_childFrameCreationCount++;
-        WebFrame* frame = WebLocalFrame::create(m_client);
+        WebFrame* frame = WebLocalFrame::create(m_childClient);
         parent->appendChild(frame);
         return frame;
     }
 
-    virtual void frameDetached(WebFrame* frame) OVERRIDE
+    virtual void didStartLoading(bool toDifferentDocument)
     {
-        if (frame->parent())
-            frame->parent()->removeChild(frame);
-        frame->close();
+        if (m_parentClient) {
+            m_parentClient->didStartLoading(toDifferentDocument);
+            return;
+        }
+        TestWebFrameClient::didStartLoading(toDifferentDocument);
+    }
+
+    virtual void didStopLoading()
+    {
+        if (m_parentClient) {
+            m_parentClient->didStopLoading();
+            return;
+        }
+        TestWebFrameClient::didStopLoading();
     }
 
     virtual void willSendRequest(WebLocalFrame* frame, unsigned, WebURLRequest& request, const WebURLResponse&) OVERRIDE
     {
         m_policy = request.cachePolicy();
         m_willSendRequestCallCount++;
     }
 
 private:
+    TestCachePolicyWebFrameClient* m_parentClient;
+
     WebURLRequest::CachePolicy m_policy;
-    WebFrameClient* m_client;
+    TestCachePolicyWebFrameClient* m_childClient;
     int m_willSendRequestCallCount;
     int m_childFrameCreationCount;
 };
 
 TEST_F(WebFrameTest, ReloadIframe)
 {
     registerMockedHttpURLLoad("iframe_reload.html");
     registerMockedHttpURLLoad("visible_iframe.html");
-    TestCachePolicyWebFrameClient mainClient;
-    TestCachePolicyWebFrameClient childClient;
+    TestCachePolicyWebFrameClient mainClient(0);
+    TestCachePolicyWebFrameClient childClient(&mainClient);
     mainClient.setChildWebFrameClient(&childClient);
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "iframe_reload.html", true, &mainClient);
 
     WebLocalFrameImpl* mainFrame = webViewHelper.webViewImpl()->mainFrameImpl();
     RefPtr<WebLocalFrameImpl> childFrame = toWebLocalFrameImpl(mainFrame->firstChild());
     ASSERT_EQ(childFrame->client(), &childClient);
     EXPECT_EQ(mainClient.childFrameCreationCount(), 1);
     EXPECT_EQ(childClient.willSendRequestCallCount(), 1);
     EXPECT_EQ(childClient.cachePolicy(), WebURLRequest::UseProtocolCachePolicy);
 
-    mainFrame->reload(false);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::reloadFrame(mainFrame);
 
     // A new WebFrame should have been created, but the child WebFrameClient should be reused.
     ASSERT_NE(childFrame, toWebLocalFrameImpl(mainFrame->firstChild()));
     ASSERT_EQ(toWebLocalFrameImpl(mainFrame->firstChild())->client(), &childClient);
 
     EXPECT_EQ(mainClient.childFrameCreationCount(), 2);
     EXPECT_EQ(childClient.willSendRequestCallCount(), 2);
     EXPECT_EQ(childClient.cachePolicy(), WebURLRequest::ReloadIgnoringCacheData);
 }
 
@@ skipping 19 matching lines @@
 TEST_F(WebFrameTest, NavigateToSame)
 {
     registerMockedHttpURLLoad("navigate_to_same.html");
     TestSameDocumentWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "navigate_to_same.html", true, &client);
     EXPECT_FALSE(client.frameLoadTypeSameSeen());
 
     WebCore::FrameLoadRequest frameRequest(0, WebCore::ResourceRequest(webViewHelper.webViewImpl()->page()->mainFrame()->document()->url()));
     webViewHelper.webViewImpl()->page()->mainFrame()->loader().load(frameRequest);
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(webViewHelper.webView()->mainFrame());
 
     EXPECT_TRUE(client.frameLoadTypeSameSeen());
 }
 
 TEST_F(WebFrameTest, WebNodeImageContents)
 {
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad("about:blank", true);
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     static const char bluePNG[] = "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAGElEQVQYV2NkYPj/n4EIwDiqEF8oUT94AFIQE/cCn90IAAAAAElFTkSuQmCC\">";
 
     // Load up the image and test that we can extract the contents.
     WebCore::KURL testURL = toKURL("about:blank");
-    frame->loadHTMLString(bluePNG, testURL);
-    runPendingTasks();
+    FrameTestHelpers::loadHTMLString(frame, bluePNG, testURL);
 
     WebNode node = frame->document().body().firstChild();
     EXPECT_TRUE(node.isElementNode());
     WebElement element = node.to<WebElement>();
     WebImage image = element.imageContents();
     ASSERT_FALSE(image.isNull());
     EXPECT_EQ(image.size().width, 10);
     EXPECT_EQ(image.size().height, 10);
 //    FIXME: The rest of this test is disabled since the ImageDecodeCache state may be inconsistent when this test runs.
 //    crbug.com/266088
 //    SkBitmap bitmap = image.getSkBitmap();
 //    SkAutoLockPixels locker(bitmap);
 //    EXPECT_EQ(bitmap.getColor(0, 0), SK_ColorBLUE);
 }
 
-class TestStartStopCallbackWebFrameClient : public WebFrameClient {
+class TestStartStopCallbackWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestStartStopCallbackWebFrameClient()
         : m_startLoadingCount(0)
         , m_stopLoadingCount(0)
         , m_differentDocumentStartCount(0)
     {
     }
 
     virtual void didStartLoading(bool toDifferentDocument) OVERRIDE
     {
+        TestWebFrameClient::didStartLoading(toDifferentDocument);
         m_startLoadingCount++;
         if (toDifferentDocument)
             m_differentDocumentStartCount++;
     }
 
     virtual void didStopLoading() OVERRIDE
     {
+        TestWebFrameClient::didStopLoading();
         m_stopLoadingCount++;
     }
 
     int startLoadingCount() const { return m_startLoadingCount; }
     int stopLoadingCount() const { return m_stopLoadingCount; }
     int differentDocumentStartCount() const { return m_differentDocumentStartCount; }
 
 private:
     int m_startLoadingCount;
     int m_stopLoadingCount;
     int m_differentDocumentStartCount;
 };
 
 TEST_F(WebFrameTest, PushStateStartsAndStops)
 {
     registerMockedHttpURLLoad("push_state.html");
     TestStartStopCallbackWebFrameClient client;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "push_state.html", true, &client);
-    runPendingTasks();
 
     EXPECT_EQ(client.startLoadingCount(), 2);
     EXPECT_EQ(client.stopLoadingCount(), 2);
     EXPECT_EQ(client.differentDocumentStartCount(), 1);
 }
 
-class TestHistoryWebFrameClient : public WebFrameClient {
+class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
 public:
     TestHistoryWebFrameClient()
     {
         m_replacesCurrentHistoryItem = false;
         m_frame = 0;
     }
     void didStartProvisionalLoad(WebLocalFrame* frame)
     {
         WebDataSource* ds = frame->provisionalDataSource();
         m_replacesCurrentHistoryItem = ds->replacesCurrentHistoryItem();
@@ skipping 11 matching lines @@
 // Test which ensures that the first navigation in a subframe will always
 // result in history entry being replaced and not a new one added.
 TEST_F(WebFrameTest, DISABLED_FirstFrameNavigationReplacesHistory)
 {
     registerMockedHttpURLLoad("history.html");
     registerMockedHttpURLLoad("find.html");
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     TestHistoryWebFrameClient client;
     webViewHelper.initializeAndLoad("about:blank", true, &client);
-    runPendingTasks();
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     WebFrame* frame = webViewHelper.webView()->mainFrame();
 
     FrameTestHelpers::loadFrame(frame,
         "javascript:document.body.appendChild(document.createElement('iframe'))");
-    // Need to call runPendingTasks in order for the JavaScript above to be
-    // evaluated and executed.
-    runPendingTasks();
     WebFrame* iframe = frame->firstChild();
     EXPECT_EQ(client.frame(), iframe);
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     FrameTestHelpers::loadFrame(frame,
         "javascript:window.frames[0].location.assign('" + m_baseURL + "history.html')");
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_EQ(client.frame(), iframe);
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     FrameTestHelpers::loadFrame(frame,
         "javascript:window.frames[0].location.assign('" + m_baseURL + "find.html')");
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_EQ(client.frame(), iframe);
     EXPECT_FALSE(client.replacesCurrentHistoryItem());
 
     // Repeat the test, but start out the iframe with initial URL, which is not
     // "about:blank".
     FrameTestHelpers::loadFrame(frame,
         "javascript:var f = document.createElement('iframe'); "
         "f.src = '" + m_baseURL + "history.html';"
         "document.body.appendChild(f)");
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
 
     iframe = frame->firstChild()->nextSibling();
     EXPECT_EQ(client.frame(), iframe);
     EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
     FrameTestHelpers::loadFrame(frame,
         "javascript:window.frames[1].location.assign('" + m_baseURL + "find.html')");
-    runPendingTasks();
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
     EXPECT_EQ(client.frame(), iframe);
     EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Test verifies that layout will change a layer's scrollable attibutes
 TEST_F(WebFrameTest, overflowHiddenRewrite)
 {
     registerMockedHttpURLLoad("non-scrollable.html");
     TestMainFrameUserOrProgrammaticScrollFrameClient client;
     OwnPtr<FakeCompositingWebViewClient> fakeCompositingWebViewClient = adoptPtr(new FakeCompositingWebViewClient());
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize(true, 0, fakeCompositingWebViewClient.get(), &configueCompositingWebView);
 
     webViewHelper.webView()->resize(WebSize(100, 100));
     FrameTestHelpers::loadFrame(webViewHelper.webView()->mainFrame(), m_baseURL + "non-scrollable.html");
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
-    webViewHelper.webView()->layout();
 
     WebCore::RenderLayerCompositor* compositor =  webViewHelper.webViewImpl()->compositor();
     ASSERT_TRUE(compositor->scrollLayer());
 
     // Verify that the WebLayer is not scrollable initially.
     WebCore::GraphicsLayer* scrollLayer = compositor->scrollLayer();
     WebLayer* webScrollLayer = scrollLayer->platformLayer();
     ASSERT_FALSE(webScrollLayer->userScrollableHorizontal());
     ASSERT_FALSE(webScrollLayer->userScrollableVertical());
 
     // Call javascript to make the layer scrollable, and verify it.
     WebLocalFrameImpl* frame = (WebLocalFrameImpl*)webViewHelper.webView()->mainFrame();
     frame->executeScript(WebScriptSource("allowScroll();"));
     webViewHelper.webView()->layout();
     ASSERT_TRUE(webScrollLayer->userScrollableHorizontal());
     ASSERT_TRUE(webScrollLayer->userScrollableVertical());
 }
 
 // Test that currentHistoryItem reflects the current page, not the provisional load.
 TEST_F(WebFrameTest, CurrentHistoryItem)
 {
     registerMockedHttpURLLoad("fixed_layout.html");
     std::string url = m_baseURL + "fixed_layout.html";
 
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initialize();
     WebFrame* frame = webViewHelper.webView()->mainFrame();
     const WebCore::FrameLoader& mainFrameLoader = webViewHelper.webViewImpl()->mainFrameImpl()->frame()->loader();
-    FrameTestHelpers::loadFrame(frame, url);
+    WebURLRequest request;
+    request.initialize();
+    request.setURL(toKURL(url));
+    frame->loadRequest(request);
 
     // Before commit, there is no history item.
     EXPECT_FALSE(mainFrameLoader.currentItem());
 
-    Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    FrameTestHelpers::pumpPendingRequestsDoNotUse(frame);
 
     // After commit, there is.
     WebCore::HistoryItem* item = mainFrameLoader.currentItem();
     ASSERT_TRUE(item);
     EXPECT_EQ(WTF::String(url.data()), item->urlString());
 }
 
-class FailCreateChildFrame : public WebFrameClient {
+class FailCreateChildFrame : public FrameTestHelpers::TestWebFrameClient {
 public:
     FailCreateChildFrame() : m_callCount(0) { }
 
     virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString& frameName) OVERRIDE
     {
         ++m_callCount;
         return 0;
     }
 
-    virtual void frameDetached(WebFrame* frame) OVERRIDE
-    {
-        frame->close();
-    }
-
     int callCount() const { return m_callCount; }
 
 private:
     int m_callCount;
 };
 
 // Test that we don't crash if WebFrameClient::createChildFrame() fails.
 TEST_F(WebFrameTest, CreateChildFrameFailure)
 {
     registerMockedHttpURLLoad("create_child_frame_fail.html");
@@ skipping 155 matching lines @@
     registerMockedHttpURLLoad("link-manifest-change.html");
 
     ManifestChangeWebFrameClient webFrameClient;
     FrameTestHelpers::WebViewHelper webViewHelper;
     webViewHelper.initializeAndLoad(m_baseURL + "link-manifest-change.html", true, &webFrameClient);
 
     EXPECT_EQ(14, webFrameClient.manifestChangeCount());
 }
 
 } // namespace